From d8c406d2cc7195f323c448834bcc77cb29cdfe8d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:12:45 +0000
Subject: [PATCH 01/22] Initial plan


From 5fb3f1e8e688cab81b06d95f05125daaa1e68e3b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:16:31 +0000
Subject: [PATCH 02/22] Add tab navigation manager (js/tabs.js)

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/tabs.js | 178 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 178 insertions(+)
 create mode 100644 js/tabs.js

diff --git a/js/tabs.js b/js/tabs.js
new file mode 100644
index 0000000..dc90db0
--- /dev/null
+++ b/js/tabs.js
@@ -0,0 +1,178 @@
+/**
+ * tabs.js
+ *
+ * @fileoverview Módulo de gerenciamento de navegação por abas para o BINGO Layout Generator.
+ *
+ * @description Gerencia a navegação entre as abas da aplicação:
+ * - Layout Principal (tab-layout)
+ * - Configuração OSKAR (tab-oskar-config)
+ * - Modelo de Céu (tab-sky-model)
+ * - Cobertura UV (tab-uv-coverage)
+ *
+ * Utiliza arquitetura orientada a eventos com eventos customizados 'tabChanged',
+ * suporte a navegação por teclado e troca programática de abas.
+ *
+ * @author Geovanni Fernandes Garcia
+ * @version 1.0.2
+ */
+
+'use strict';
+
+class TabManager {
+    /**
+     * Cria uma instância do TabManager.
+     * Inicializa os botões de aba, painéis de conteúdo e configura os event listeners.
+     */
+    constructor() {
+        /** @type {NodeListOf<HTMLElement>} */
+        this.tabButtons = document.querySelectorAll('.tab-btn');
+
+        /** @type {NodeListOf<HTMLElement>} */
+        this.tabPanels = document.querySelectorAll('.tab-content');
+
+        /** @type {string|null} ID da aba ativa atual */
+        this.activeTabId = null;
+
+        /** @type {string[]} Lista ordenada de IDs de abas para navegação por teclado */
+        this.tabIds = [
+            'tab-layout',
+            'tab-oskar-config',
+            'tab-sky-model',
+            'tab-uv-coverage'
+        ];
+
+        this.init();
+    }
+
+    /**
+     * Inicializa o gerenciador de abas.
+     * Configura os listeners de clique e teclado, e ativa a primeira aba.
+     */
+    init() {
+        this.tabButtons.forEach((btn) => {
+            btn.addEventListener('click', () => {
+                const tabId = btn.getAttribute('data-tab');
+                if (tabId) {
+                    this.switchToTab(tabId);
+                }
+            });
+
+            btn.addEventListener('keydown', (e) => {
+                this.handleKeyDown(e);
+            });
+        });
+
+        // Ativa a primeira aba disponível
+        const initialTab = this.findInitialTab();
+        if (initialTab) {
+            this.switchToTab(initialTab);
+        }
+    }
+
+    /**
+     * Determina a aba inicial a ser ativada.
+     * Usa a aba já marcada como ativa ou a primeira da lista.
+     * @returns {string|null} ID da aba inicial
+     */
+    findInitialTab() {
+        const activeBtn = document.querySelector('.tab-btn.active');
+        if (activeBtn) {
+            const tabId = activeBtn.getAttribute('data-tab');
+            if (tabId) {
+                return tabId;
+            }
+        }
+        return this.tabIds[0] || null;
+    }
+
+    /**
+     * Troca para a aba especificada pelo ID.
+     * Atualiza as classes ativas nos botões e painéis, e dispara o evento 'tabChanged'.
+     * @param {string} tabId - ID do painel de conteúdo da aba destino
+     */
+    switchToTab(tabId) {
+        if (tabId === this.activeTabId) {
+            return;
+        }
+
+        const targetBtn = document.querySelector(`.tab-btn[data-tab="${tabId}"]`);
+        const targetPanel = document.getElementById(tabId);
+
+        if (!targetBtn || !targetPanel) {
+            console.warn(`TabManager: aba "${tabId}" não encontrada.`);
+            return;
+        }
+
+        const previousTabId = this.activeTabId;
+
+        // Remove classe ativa de todos os botões e painéis
+        this.tabButtons.forEach((btn) => btn.classList.remove('active'));
+        this.tabPanels.forEach((panel) => panel.classList.remove('active'));
+
+        // Ativa o botão e painel selecionados
+        targetBtn.classList.add('active');
+        targetPanel.classList.add('active');
+
+        this.activeTabId = tabId;
+
+        // Dispara evento customizado
+        document.dispatchEvent(new CustomEvent('tabChanged', {
+            detail: {
+                tabId: tabId,
+                previousTabId: previousTabId
+            }
+        }));
+    }
+
+    /**
+     * Manipula a navegação por teclado entre as abas.
+     * Setas esquerda/direita movem entre abas adjacentes.
+     * Home/End movem para a primeira/última aba.
+     * @param {KeyboardEvent} e - Evento de teclado
+     */
+    handleKeyDown(e) {
+        const currentIndex = this.tabIds.indexOf(this.activeTabId);
+        if (currentIndex === -1) {
+            return;
+        }
+
+        let newIndex = -1;
+
+        switch (e.key) {
+            case 'ArrowRight':
+            case 'ArrowDown':
+                newIndex = (currentIndex + 1) % this.tabIds.length;
+                break;
+            case 'ArrowLeft':
+            case 'ArrowUp':
+                newIndex = (currentIndex - 1 + this.tabIds.length) % this.tabIds.length;
+                break;
+            case 'Home':
+                newIndex = 0;
+                break;
+            case 'End':
+                newIndex = this.tabIds.length - 1;
+                break;
+            default:
+                return;
+        }
+
+        e.preventDefault();
+        this.switchToTab(this.tabIds[newIndex]);
+
+        // Move o foco para o botão da nova aba
+        const newBtn = document.querySelector(`.tab-btn[data-tab="${this.tabIds[newIndex]}"]`);
+        if (newBtn) {
+            newBtn.focus();
+        }
+    }
+}
+
+// === Instanciação e Exportação Global ===
+if (typeof window !== 'undefined') {
+    document.addEventListener('DOMContentLoaded', () => {
+        if (!window.tabManager) {
+            window.tabManager = new TabManager();
+        }
+    });
+}

From 91461de6e858e51ca4934554c6522011e51d4fa6 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:20:30 +0000
Subject: [PATCH 03/22] Add Station Manager module (js/stations.js)

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/stations.js | 533 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 533 insertions(+)
 create mode 100644 js/stations.js

diff --git a/js/stations.js b/js/stations.js
new file mode 100644
index 0000000..988901c
--- /dev/null
+++ b/js/stations.js
@@ -0,0 +1,533 @@
+/**
+ * stations.js
+ *
+ * @fileoverview Módulo para gerenciamento e visualização de posições de estações em grande escala.
+ * Gera layouts de estações (~30x a escala de tiles), calcula baselines entre pares
+ * de estações e a resolução angular correspondente.
+ *
+ * @description Suporta seis tipos de layout: grid, circular, spiral, y_shape, cross e random.
+ * Distâncias de estações variam de ~15m a 3km, com espaçamento padrão de ~300m.
+ * Calcula todas as baselines entre pares de estações, resolução angular (theta ≈ λ/D_max)
+ * e exibe estatísticas atualizadas dinamicamente.
+ *
+ * @requires BingoConstants
+ * @author Geovanni Fernandes Garcia
+ * @version 1.0.2
+ */
+
+'use strict';
+
+// Constantes físicas - usar BingoConstants quando disponível, senão valores padrão
+const STATION_WAVELENGTH = (typeof BingoConstants !== 'undefined') ? BingoConstants.WAVELENGTH : 299792458 / 1e9;
+const STATION_SPEED_OF_LIGHT = (typeof BingoConstants !== 'undefined') ? BingoConstants.SPEED_OF_LIGHT : 299792458;
+const STATION_FREQUENCY_HZ = (typeof BingoConstants !== 'undefined') ? BingoConstants.FREQUENCY_HZ : 1e9;
+const STATION_DEG_TO_RAD = (typeof BingoConstants !== 'undefined') ? BingoConstants.DEG_TO_RAD : Math.PI / 180;
+const STATION_RAD_TO_DEG = (typeof BingoConstants !== 'undefined') ? BingoConstants.RAD_TO_DEG : 180 / Math.PI;
+
+/**
+ * Fator de escala das estações em relação aos tiles (~30x).
+ * @constant {number}
+ */
+const STATION_SCALE_FACTOR = 30;
+
+/**
+ * Espaçamento padrão entre estações em metros.
+ * @constant {number}
+ */
+const DEFAULT_STATION_SPACING = 300;
+
+/**
+ * Espaçamento mínimo entre estações em metros.
+ * @constant {number}
+ */
+const MIN_STATION_SPACING = 15;
+
+/**
+ * Espaçamento máximo entre estações em metros.
+ * @constant {number}
+ */
+const MAX_STATION_SPACING = 3000;
+
+/**
+ * Limiar para baselines curtas em metros.
+ * @constant {number}
+ */
+const SHORT_BASELINE_THRESHOLD = 50;
+
+/**
+ * Limiar para baselines longas em metros.
+ * @constant {number}
+ */
+const LONG_BASELINE_THRESHOLD = 1000;
+
+class StationManager {
+    constructor() {
+        // IDs dos elementos da UI
+        this.layoutTypeSelectId = 'station-layout-type';
+        this.stationCountInputId = 'station-count';
+        this.spacingRangeId = 'station-spacing';
+        this.spacingValueDisplayId = 'station-spacing-value';
+        this.generateBtnId = 'station-generate-btn';
+        this.randomBtnId = 'station-random-btn';
+        this.statsContainerId = 'station-stats';
+        this.angularResDisplayId = 'angular-resolution-display';
+        this.baselineInfoId = 'baseline-info';
+
+        // Referências aos elementos DOM
+        this.layoutTypeSelect = null;
+        this.stationCountInput = null;
+        this.spacingRange = null;
+        this.spacingValueDisplay = null;
+        this.generateBtn = null;
+        this.randomBtn = null;
+        this.statsContainer = null;
+        this.angularResDisplay = null;
+        this.baselineInfo = null;
+
+        // Estado interno
+        this.stations = [];
+        this.baselines = [];
+        this.maxBaseline = 0;
+        this.minBaseline = Infinity;
+
+        this._init();
+    }
+
+    _init() {
+        this.layoutTypeSelect = document.getElementById(this.layoutTypeSelectId);
+        this.stationCountInput = document.getElementById(this.stationCountInputId);
+        this.spacingRange = document.getElementById(this.spacingRangeId);
+        this.spacingValueDisplay = document.getElementById(this.spacingValueDisplayId);
+        this.generateBtn = document.getElementById(this.generateBtnId);
+        this.randomBtn = document.getElementById(this.randomBtnId);
+        this.statsContainer = document.getElementById(this.statsContainerId);
+        this.angularResDisplay = document.getElementById(this.angularResDisplayId);
+        this.baselineInfo = document.getElementById(this.baselineInfoId);
+
+        if (!this.generateBtn && !this.layoutTypeSelect) {
+            console.warn("StationManager: Elementos DOM de estações não encontrados. Módulo em modo stand-by.");
+            return;
+        }
+
+        if (this.generateBtn) {
+            this.generateBtn.addEventListener('click', () => this.generateStations());
+        }
+        if (this.randomBtn) {
+            this.randomBtn.addEventListener('click', () => {
+                if (this.layoutTypeSelect) {
+                    this.layoutTypeSelect.value = 'random';
+                }
+                this.generateStations();
+            });
+        }
+        if (this.spacingRange) {
+            this.spacingRange.addEventListener('input', () => this._updateSpacingDisplay());
+        }
+
+        this._updateSpacingDisplay();
+        console.log("StationManager: Módulo de estações inicializado.");
+    }
+
+    /**
+     * Converte o valor linear do range input para escala logarítmica.
+     * @returns {number} Espaçamento em metros (escala log).
+     */
+    _getSpacingFromRange() {
+        if (!this.spacingRange) return DEFAULT_STATION_SPACING;
+        const t = parseFloat(this.spacingRange.value);
+        const logMin = Math.log10(MIN_STATION_SPACING);
+        const logMax = Math.log10(MAX_STATION_SPACING);
+        return Math.pow(10, logMin + t * (logMax - logMin));
+    }
+
+    /**
+     * Atualiza o display do valor de espaçamento.
+     */
+    _updateSpacingDisplay() {
+        const spacing = this._getSpacingFromRange();
+        if (this.spacingValueDisplay) {
+            if (spacing >= 1000) {
+                this.spacingValueDisplay.textContent = `${(spacing / 1000).toFixed(2)} km`;
+            } else {
+                this.spacingValueDisplay.textContent = `${spacing.toFixed(1)} m`;
+            }
+        }
+    }
+
+    /**
+     * Gera posições de estações com base nas configurações atuais da UI.
+     */
+    generateStations() {
+        const layoutType = this.layoutTypeSelect ? this.layoutTypeSelect.value : 'grid';
+        const count = this.stationCountInput ? parseInt(this.stationCountInput.value, 10) : 7;
+        const spacing = this._getSpacingFromRange();
+
+        if (isNaN(count) || count < 1) {
+            console.error("StationManager: Número de estações inválido.");
+            return;
+        }
+
+        switch (layoutType) {
+            case 'grid':
+                this.stations = this.generateGridStations(count, spacing);
+                break;
+            case 'circular':
+                this.stations = this.generateCircularStations(count, spacing);
+                break;
+            case 'spiral':
+                this.stations = this.generateSpiralStations(count, spacing);
+                break;
+            case 'y_shape':
+                this.stations = this.generateYShapeStations(count, spacing);
+                break;
+            case 'cross':
+                this.stations = this.generateCrossStations(count, spacing);
+                break;
+            case 'random':
+                this.stations = this.generateRandomStations(count, spacing);
+                break;
+            default:
+                console.warn(`StationManager: Tipo de layout desconhecido '${layoutType}'. Usando grid.`);
+                this.stations = this.generateGridStations(count, spacing);
+        }
+
+        this._centerStations();
+        this.calculateBaselines();
+        this.calculateAngularResolution();
+        this.updateStats();
+        this._dispatchEvent();
+
+        console.log(`StationManager: ${this.stations.length} estações geradas (layout: ${layoutType}, espaçamento: ${spacing.toFixed(1)}m).`);
+    }
+
+    /**
+     * Centraliza as estações em torno da origem (0, 0).
+     */
+    _centerStations() {
+        if (this.stations.length === 0) return;
+        let sumX = 0, sumY = 0;
+        for (const s of this.stations) {
+            sumX += s.x;
+            sumY += s.y;
+        }
+        const cx = sumX / this.stations.length;
+        const cy = sumY / this.stations.length;
+        this.stations = this.stations.map(s => ({
+            x: s.x - cx,
+            y: s.y - cy
+        }));
+    }
+
+    // ===========================
+    // Métodos de Geração de Layout
+    // ===========================
+
+    /**
+     * Gera estações em um grid regular.
+     * @param {number} count Número de estações.
+     * @param {number} spacing Espaçamento em metros.
+     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     */
+    generateGridStations(count, spacing) {
+        const cols = Math.ceil(Math.sqrt(count));
+        const rows = Math.ceil(count / cols);
+        const positions = [];
+        for (let r = 0; r < rows && positions.length < count; r++) {
+            for (let c = 0; c < cols && positions.length < count; c++) {
+                positions.push({
+                    x: c * spacing,
+                    y: r * spacing
+                });
+            }
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações em um anel circular.
+     * @param {number} count Número de estações.
+     * @param {number} spacing Espaçamento em metros (usado como raio).
+     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     */
+    generateCircularStations(count, spacing) {
+        const positions = [];
+        const radius = spacing;
+        for (let i = 0; i < count; i++) {
+            const angle = (2 * Math.PI * i) / count;
+            positions.push({
+                x: radius * Math.cos(angle),
+                y: radius * Math.sin(angle)
+            });
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações em uma espiral.
+     * @param {number} count Número de estações.
+     * @param {number} spacing Espaçamento em metros (controla o passo radial).
+     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     */
+    generateSpiralStations(count, spacing) {
+        const positions = [];
+        const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+        for (let i = 0; i < count; i++) {
+            const r = spacing * Math.sqrt(i + 1) / Math.sqrt(count);
+            const theta = i * goldenAngle;
+            positions.push({
+                x: r * Math.cos(theta),
+                y: r * Math.sin(theta)
+            });
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações em um layout em forma de Y (comum em radioastronomia).
+     * @param {number} count Número de estações.
+     * @param {number} spacing Espaçamento em metros.
+     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     */
+    generateYShapeStations(count, spacing) {
+        const positions = [];
+        const arms = 3;
+        const perArm = Math.floor(count / arms);
+        const remainder = count - perArm * arms;
+        const armAngles = [
+            Math.PI / 2,                    // braço superior (90°)
+            Math.PI / 2 + (2 * Math.PI / 3), // braço inferior esquerdo (210°)
+            Math.PI / 2 + (4 * Math.PI / 3)  // braço inferior direito (330°)
+        ];
+
+        for (let a = 0; a < arms; a++) {
+            const stationsInArm = perArm + (a < remainder ? 1 : 0);
+            const angle = armAngles[a];
+            for (let i = 0; i < stationsInArm; i++) {
+                const dist = spacing * (i + 1);
+                positions.push({
+                    x: dist * Math.cos(angle),
+                    y: dist * Math.sin(angle)
+                });
+            }
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações em um layout em forma de cruz.
+     * @param {number} count Número de estações.
+     * @param {number} spacing Espaçamento em metros.
+     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     */
+    generateCrossStations(count, spacing) {
+        const positions = [];
+        const arms = 4;
+        const perArm = Math.floor(count / arms);
+        const remainder = count - perArm * arms;
+        const armAngles = [0, Math.PI / 2, Math.PI, 3 * Math.PI / 2];
+
+        for (let a = 0; a < arms; a++) {
+            const stationsInArm = perArm + (a < remainder ? 1 : 0);
+            for (let i = 0; i < stationsInArm; i++) {
+                const dist = spacing * (i + 1);
+                positions.push({
+                    x: dist * Math.cos(armAngles[a]),
+                    y: dist * Math.sin(armAngles[a])
+                });
+            }
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações com distribuição aleatória.
+     * @param {number} count Número de estações.
+     * @param {number} spacing Espaçamento em metros (define o raio da área).
+     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     */
+    generateRandomStations(count, spacing) {
+        const positions = [];
+        const area = spacing * Math.sqrt(count);
+        for (let i = 0; i < count; i++) {
+            positions.push({
+                x: (Math.random() - 0.5) * 2 * area,
+                y: (Math.random() - 0.5) * 2 * area
+            });
+        }
+        return positions;
+    }
+
+    // ===========================
+    // Cálculos de Baselines
+    // ===========================
+
+    /**
+     * Calcula todas as baselines (distâncias) entre pares de estações.
+     */
+    calculateBaselines() {
+        this.baselines = [];
+        this.maxBaseline = 0;
+        this.minBaseline = Infinity;
+        const n = this.stations.length;
+
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                const dx = this.stations[j].x - this.stations[i].x;
+                const dy = this.stations[j].y - this.stations[i].y;
+                const dist = Math.sqrt(dx * dx + dy * dy);
+
+                let category;
+                if (dist < SHORT_BASELINE_THRESHOLD) {
+                    category = 'short';
+                } else if (dist > LONG_BASELINE_THRESHOLD) {
+                    category = 'long';
+                } else {
+                    category = 'medium';
+                }
+
+                this.baselines.push({
+                    i: i,
+                    j: j,
+                    distance: dist,
+                    category: category
+                });
+
+                if (dist > this.maxBaseline) this.maxBaseline = dist;
+                if (dist < this.minBaseline) this.minBaseline = dist;
+            }
+        }
+
+        if (this.baselines.length === 0) {
+            this.minBaseline = 0;
+        }
+
+        this._updateBaselineInfo();
+    }
+
+    /**
+     * Atualiza o display de informações de baselines.
+     */
+    _updateBaselineInfo() {
+        if (!this.baselineInfo) return;
+
+        if (this.baselines.length === 0) {
+            this.baselineInfo.textContent = 'Nenhuma baseline calculada.';
+            return;
+        }
+
+        const shortCount = this.baselines.filter(b => b.category === 'short').length;
+        const mediumCount = this.baselines.filter(b => b.category === 'medium').length;
+        const longCount = this.baselines.filter(b => b.category === 'long').length;
+
+        const formatDist = (d) => d >= 1000 ? `${(d / 1000).toFixed(2)} km` : `${d.toFixed(1)} m`;
+
+        this.baselineInfo.innerHTML =
+            `<strong>Baselines:</strong> ${this.baselines.length} pares<br>` +
+            `Min: ${formatDist(this.minBaseline)} | Max: ${formatDist(this.maxBaseline)}<br>` +
+            `<span style="color:#4caf50">Curtas (&lt;${SHORT_BASELINE_THRESHOLD}m): ${shortCount}</span> | ` +
+            `<span style="color:#ff9800">Médias: ${mediumCount}</span> | ` +
+            `<span style="color:#f44336">Longas (&gt;${LONG_BASELINE_THRESHOLD}m): ${longCount}</span>`;
+    }
+
+    // ===========================
+    // Resolução Angular
+    // ===========================
+
+    /**
+     * Calcula e exibe a resolução angular: theta ≈ lambda / D_max.
+     */
+    calculateAngularResolution() {
+        if (!this.angularResDisplay) return;
+
+        if (this.maxBaseline <= 0) {
+            this.angularResDisplay.textContent = 'Resolução angular: N/A (sem baselines)';
+            return;
+        }
+
+        const thetaRad = STATION_WAVELENGTH / this.maxBaseline;
+        const thetaDeg = thetaRad * STATION_RAD_TO_DEG;
+        const thetaArcmin = thetaDeg * 60;
+        const thetaArcsec = thetaArcmin * 60;
+
+        let display;
+        if (thetaArcmin >= 1) {
+            display = `${thetaArcmin.toFixed(2)} arcmin`;
+        } else {
+            display = `${thetaArcsec.toFixed(2)} arcsec`;
+        }
+
+        this.angularResDisplay.innerHTML =
+            `<strong>Resolução Angular (θ ≈ λ/D<sub>max</sub>):</strong><br>` +
+            `θ = ${display}<br>` +
+            `λ = ${STATION_WAVELENGTH.toFixed(4)} m | D<sub>max</sub> = ${this._formatDistance(this.maxBaseline)}<br>` +
+            `f = ${(STATION_FREQUENCY_HZ / 1e9).toFixed(3)} GHz`;
+    }
+
+    /**
+     * Formata distância para exibição (m ou km).
+     * @param {number} dist Distância em metros.
+     * @returns {string} Distância formatada.
+     */
+    _formatDistance(dist) {
+        return dist >= 1000 ? `${(dist / 1000).toFixed(2)} km` : `${dist.toFixed(1)} m`;
+    }
+
+    // ===========================
+    // Estatísticas e Eventos
+    // ===========================
+
+    /**
+     * Atualiza o container de estatísticas com informações do layout atual.
+     */
+    updateStats() {
+        if (!this.statsContainer) return;
+
+        if (this.stations.length === 0) {
+            this.statsContainer.textContent = 'Nenhuma estação gerada.';
+            return;
+        }
+
+        let maxR = 0;
+        for (const s of this.stations) {
+            const r = Math.sqrt(s.x * s.x + s.y * s.y);
+            if (r > maxR) maxR = r;
+        }
+
+        this.statsContainer.innerHTML =
+            `<strong>Estações:</strong> ${this.stations.length}<br>` +
+            `Baselines: ${this.baselines.length} pares<br>` +
+            `Raio máximo: ${this._formatDistance(maxR)}<br>` +
+            `Baseline max: ${this._formatDistance(this.maxBaseline)}`;
+    }
+
+    /**
+     * Retorna as posições atuais das estações.
+     * @returns {Array<{x: number, y: number}>} Array de posições em metros.
+     */
+    getStationPositions() {
+        return this.stations.slice();
+    }
+
+    /**
+     * Dispara evento customizado notificando que estações foram geradas.
+     */
+    _dispatchEvent() {
+        window.dispatchEvent(new CustomEvent('stationsGenerated', {
+            detail: {
+                stations: this.getStationPositions(),
+                baselines: this.baselines,
+                maxBaseline: this.maxBaseline,
+                minBaseline: this.minBaseline
+            }
+        }));
+    }
+}
+
+// Inicialização e exposição global
+if (typeof window !== 'undefined') {
+    document.addEventListener('DOMContentLoaded', () => {
+        if (!window.stationManager) {
+            window.stationManager = new StationManager();
+        }
+    });
+}

From 00e015979a59379b325ba41ff51f7ba80d4c0a5f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:24:53 +0000
Subject: [PATCH 04/22] Add OSKAR INI file generator module
 (js/ini_generator.js)

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/ini_generator.js | 844 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 844 insertions(+)
 create mode 100644 js/ini_generator.js

diff --git a/js/ini_generator.js b/js/ini_generator.js
new file mode 100644
index 0000000..7843aa9
--- /dev/null
+++ b/js/ini_generator.js
@@ -0,0 +1,844 @@
+/**
+ * ini_generator.js
+ *
+ * @fileoverview Módulo gerador de arquivos .ini de configuração para o simulador OSKAR.
+ *
+ * @description Permite ao usuário configurar os parâmetros de simulação do OSKAR
+ * organizados em categorias (Essenciais, Recomendados e Avançados), gerar a
+ * pré-visualização do arquivo .ini, validar campos e exportar/copiar o resultado.
+ *
+ * @requires BingoConstants
+ * @author Geovanni Fernandes Garcia
+ * @version 1.0.2
+ */
+
+'use strict';
+
+// Constantes do BINGO Central - usar BingoConstants quando disponível
+const INI_BINGO_LATITUDE = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_LATITUDE : -7.04067;
+const INI_BINGO_LONGITUDE = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_LONGITUDE : -38.26884;
+const INI_BINGO_ALTITUDE = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_ALTITUDE : 396.4;
+
+/**
+ * Definição dos parâmetros OSKAR suportados pelo gerador.
+ * Cada entrada descreve um parâmetro de configuração do .ini.
+ * @constant {Array<Object>}
+ */
+const OSKAR_INI_PARAMS = Object.freeze([
+    // =========================================================================
+    // [simulator]
+    // =========================================================================
+    {
+        key: 'max_sources_per_chunk',
+        section: 'simulator',
+        label: 'Fontes por bloco',
+        tooltip: 'Número máximo de fontes de céu processadas simultaneamente por bloco de memória. ' +
+                 'Valores maiores usam mais memória da GPU, mas podem ser mais rápidos. ' +
+                 'Reduza se ocorrerem erros de falta de memória na GPU.',
+        type: 'number',
+        defaultValue: 16384,
+        category: 'advanced'
+    },
+    {
+        key: 'double_precision',
+        section: 'simulator',
+        label: 'Precisão dupla',
+        tooltip: 'Ativa cálculos em precisão dupla (64 bits) em vez de precisão simples (32 bits). ' +
+                 'Precisão dupla é mais exata, porém significativamente mais lenta na GPU. ' +
+                 'Use "true" para simulações de alta fidelidade.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim (mais preciso, mais lento)' },
+            { value: 'false', label: 'Não (mais rápido, precisão simples)' }
+        ]
+    },
+    {
+        key: 'keep_log_file',
+        section: 'simulator',
+        label: 'Manter log',
+        tooltip: 'Quando habilitado, o OSKAR salva um arquivo de log detalhado com informações ' +
+                 'sobre o progresso e eventuais erros da simulação. Útil para depuração.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+
+    // =========================================================================
+    // [sky]
+    // =========================================================================
+    {
+        key: 'oskar_sky_model/file',
+        section: 'sky',
+        label: 'Arquivo do modelo de céu',
+        tooltip: 'Caminho para o arquivo do modelo de céu (.osm ou .txt) contendo as fontes ' +
+                 'a serem simuladas. Cada linha define uma fonte com posição (RA, Dec) e fluxo. ' +
+                 'Este é um parâmetro obrigatório para executar a simulação.',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true
+    },
+
+    // =========================================================================
+    // [observation]
+    // =========================================================================
+    {
+        key: 'start_frequency_hz',
+        section: 'observation',
+        label: 'Frequência inicial (Hz)',
+        tooltip: 'Frequência central do primeiro canal de observação, em Hertz. ' +
+                 'Para o BINGO, a faixa de operação é de 980 MHz a 1260 MHz. ' +
+                 'Exemplo: 980000000 para 980 MHz.',
+        type: 'number',
+        defaultValue: 980000000,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'num_channels',
+        section: 'observation',
+        label: 'Número de canais',
+        tooltip: 'Quantidade de canais de frequência na observação. Cada canal é separado pelo ' +
+                 'incremento de frequência definido abaixo. Para o BINGO com banda de 280 MHz ' +
+                 'e resolução de 1 MHz, use 280 canais.',
+        type: 'number',
+        defaultValue: 1,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'frequency_inc_hz',
+        section: 'observation',
+        label: 'Incremento de frequência (Hz)',
+        tooltip: 'Separação entre canais de frequência consecutivos, em Hertz. ' +
+                 'Define a resolução espectral da simulação. ' +
+                 'Exemplo: 1000000 para incrementos de 1 MHz.',
+        type: 'number',
+        defaultValue: 1000000,
+        category: 'recommended'
+    },
+    {
+        key: 'phase_centre_ra_deg',
+        section: 'observation',
+        label: 'Centro de fase - AR (graus)',
+        tooltip: 'Ascensão reta do centro de fase da observação, em graus decimais. ' +
+                 'Define a direção de apontamento do telescópio no eixo de ascensão reta. ' +
+                 'Para trânsito no meridiano, use 0.0.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'phase_centre_dec_deg',
+        section: 'observation',
+        label: 'Centro de fase - Dec (graus)',
+        tooltip: 'Declinação do centro de fase da observação, em graus decimais. ' +
+                 'Para o BINGO, a declinação típica de apontamento é próxima da latitude ' +
+                 'do sítio (-7.04°). Valores válidos: -90 a +90.',
+        type: 'number',
+        defaultValue: -7.04,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'start_time_utc',
+        section: 'observation',
+        label: 'Hora de início (UTC)',
+        tooltip: 'Data e hora de início da observação no formato UTC. ' +
+                 'Use o formato "dd-MM-yyyy HH:mm:ss.SSS" (ex: "01-01-2025 00:00:00.000"). ' +
+                 'O horário afeta a posição aparente das fontes no céu.',
+        type: 'text',
+        defaultValue: '01-01-2025 00:00:00.000',
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'length',
+        section: 'observation',
+        label: 'Duração da observação (s)',
+        tooltip: 'Duração total da observação em segundos. ' +
+                 'Exemplo: 3600 para uma observação de 1 hora, 86400 para 24 horas. ' +
+                 'A duração afeta a cobertura (u,v) do interferômetro.',
+        type: 'number',
+        defaultValue: 3600,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'num_time_steps',
+        section: 'observation',
+        label: 'Número de passos de tempo',
+        tooltip: 'Quantidade de amostras temporais dentro da duração total da observação. ' +
+                 'O intervalo de integração será duração/num_time_steps. ' +
+                 'Mais passos melhoram a cobertura (u,v), mas aumentam o tempo de simulação.',
+        type: 'number',
+        defaultValue: 24,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'mode',
+        section: 'observation',
+        label: 'Modo de observação',
+        tooltip: 'Modo de operação do telescópio durante a observação. ' +
+                 '"Tracking" acompanha uma posição fixa no céu (modo padrão para interferômetros). ' +
+                 '"Drift Scan" mantém o telescópio fixo enquanto o céu se move (modo típico do BINGO).',
+        type: 'select',
+        defaultValue: 'Tracking',
+        category: 'recommended',
+        options: [
+            { value: 'Tracking', label: 'Tracking (rastreio)' },
+            { value: 'Drift Scan', label: 'Drift Scan (trânsito)' }
+        ]
+    },
+
+    // =========================================================================
+    // [telescope]
+    // =========================================================================
+    {
+        key: 'input_dir',
+        section: 'telescope',
+        label: 'Diretório do telescópio',
+        tooltip: 'Caminho para o diretório contendo os arquivos de definição do telescópio OSKAR. ' +
+                 'Este diretório deve conter layout.txt, position.txt e subdiretórios das estações. ' +
+                 'Use o módulo de exportação para gerar estes arquivos.',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'longitude_deg',
+        section: 'telescope',
+        label: 'Longitude do telescópio (graus)',
+        tooltip: 'Longitude geodésica do centro de referência do telescópio, em graus decimais. ' +
+                 'Para o BINGO, a longitude é ' + INI_BINGO_LONGITUDE + '° (Paraíba, Brasil). ' +
+                 'Usada para converter coordenadas locais em celestes.',
+        type: 'number',
+        defaultValue: INI_BINGO_LONGITUDE,
+        category: 'recommended'
+    },
+    {
+        key: 'latitude_deg',
+        section: 'telescope',
+        label: 'Latitude do telescópio (graus)',
+        tooltip: 'Latitude geodésica do centro de referência do telescópio, em graus decimais. ' +
+                 'Para o BINGO, a latitude é ' + INI_BINGO_LATITUDE + '° (Paraíba, Brasil). ' +
+                 'Usada para converter coordenadas locais em celestes.',
+        type: 'number',
+        defaultValue: INI_BINGO_LATITUDE,
+        category: 'recommended'
+    },
+    {
+        key: 'pol_mode',
+        section: 'telescope',
+        label: 'Modo de polarização',
+        tooltip: 'Define o modo de polarização simulado. ' +
+                 '"Scalar" simula apenas uma polarização (mais rápido). ' +
+                 '"Full" simula as 4 correlações de polarização (XX, XY, YX, YY).',
+        type: 'select',
+        defaultValue: 'Scalar',
+        category: 'advanced',
+        options: [
+            { value: 'Scalar', label: 'Scalar (uma polarização)' },
+            { value: 'Full', label: 'Full (polarização completa)' }
+        ]
+    },
+
+    // =========================================================================
+    // [interferometer]
+    // =========================================================================
+    {
+        key: 'oskar_vis_filename',
+        section: 'interferometer',
+        label: 'Arquivo de visibilidades',
+        tooltip: 'Caminho e nome do arquivo de saída para as visibilidades simuladas (.vis). ' +
+                 'Este arquivo conterá os dados de correlação cruzada entre todas as linhas de base. ' +
+                 'Exemplo: "output/bingo_sim.vis".',
+        type: 'text',
+        defaultValue: 'output/bingo_sim.vis',
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'channel_bandwidth_hz',
+        section: 'interferometer',
+        label: 'Largura de banda do canal (Hz)',
+        tooltip: 'Largura de banda de cada canal de frequência individual, em Hertz. ' +
+                 'Usado para a decorrelação em largura de banda (bandwidth smearing). ' +
+                 'Geralmente igual ao incremento de frequência.',
+        type: 'number',
+        defaultValue: 1000000,
+        category: 'recommended'
+    },
+    {
+        key: 'time_average_sec',
+        section: 'interferometer',
+        label: 'Média temporal (s)',
+        tooltip: 'Intervalo de média temporal das visibilidades, em segundos. ' +
+                 'Usado para simular a decorrelação temporal (time smearing). ' +
+                 'Valores típicos: 1 a 10 segundos.',
+        type: 'number',
+        defaultValue: 1.0,
+        category: 'recommended'
+    },
+    {
+        key: 'max_time_samples_per_block',
+        section: 'interferometer',
+        label: 'Amostras por bloco',
+        tooltip: 'Número máximo de amostras temporais processadas por bloco na correlação. ' +
+                 'Valores maiores usam mais memória. Reduza se a GPU ficar sem memória. ' +
+                 'Valor padrão de 8 é adequado para a maioria dos casos.',
+        type: 'number',
+        defaultValue: 8,
+        category: 'advanced'
+    },
+    {
+        key: 'correlation_type',
+        section: 'interferometer',
+        label: 'Tipo de correlação',
+        tooltip: 'Define quais correlações são calculadas. ' +
+                 '"Cross-correlations" calcula apenas linhas de base cruzadas (padrão para interferometria). ' +
+                 '"Auto-correlations" calcula apenas auto-correlações. ' +
+                 '"Both" calcula ambas.',
+        type: 'select',
+        defaultValue: 'Cross-correlations',
+        category: 'advanced',
+        options: [
+            { value: 'Cross-correlations', label: 'Cross-correlations (cruzadas)' },
+            { value: 'Auto-correlations', label: 'Auto-correlations (auto)' },
+            { value: 'Both', label: 'Both (ambas)' }
+        ]
+    }
+]);
+
+/**
+ * Rótulos legíveis para as seções do INI.
+ * @constant {Object<string, string>}
+ */
+const INI_SECTION_LABELS = Object.freeze({
+    simulator: 'Simulador',
+    sky: 'Modelo de Céu',
+    observation: 'Observação',
+    telescope: 'Telescópio',
+    interferometer: 'Interferômetro'
+});
+
+/**
+ * Rótulos e ordem das categorias de parâmetros.
+ * @constant {Array<Object>}
+ */
+const INI_CATEGORIES = Object.freeze([
+    { id: 'essential',    label: 'Essenciais',   icon: 'fa-star',       collapsible: false },
+    { id: 'recommended',  label: 'Recomendados', icon: 'fa-thumbs-up',  collapsible: false },
+    { id: 'advanced',     label: 'Avançados',    icon: 'fa-cogs',       collapsible: true  }
+]);
+
+// =============================================================================
+// Classe principal
+// =============================================================================
+
+class OskarIniGenerator {
+    constructor() {
+        /** @type {Object<string, HTMLElement>} Referências aos inputs por chave composta seção.key */
+        this.inputElements = {};
+
+        /** @type {HTMLElement|null} */
+        this.paramsContainer = document.getElementById('ini-params-container');
+        /** @type {HTMLTextAreaElement|null} */
+        this.previewTextarea = document.getElementById('ini-preview');
+        /** @type {HTMLElement|null} */
+        this.validationContainer = document.getElementById('ini-validation-messages');
+
+        this._bindButtons();
+        this.renderParameters();
+        this.updatePreview();
+
+        console.log('OskarIniGenerator inicializado com sucesso.');
+    }
+
+    // =========================================================================
+    // Inicialização e bindagem de eventos
+    // =========================================================================
+
+    /**
+     * Liga os botões da UI às suas respectivas ações.
+     * @private
+     */
+    _bindButtons() {
+        const copyBtn = document.getElementById('ini-copy-btn');
+        const downloadBtn = document.getElementById('ini-download-btn');
+        const fillBtn = document.getElementById('ini-fill-from-layout-btn');
+
+        if (copyBtn) copyBtn.addEventListener('click', (e) => { e.preventDefault(); this.copyIni(); });
+        if (downloadBtn) downloadBtn.addEventListener('click', (e) => { e.preventDefault(); this.downloadIni(); });
+        if (fillBtn) fillBtn.addEventListener('click', (e) => { e.preventDefault(); this.fillFromLayout(); });
+    }
+
+    // =========================================================================
+    // Renderização de parâmetros
+    // =========================================================================
+
+    /**
+     * Renderiza todos os inputs de parâmetros agrupados por categoria e seção.
+     */
+    renderParameters() {
+        if (!this.paramsContainer) {
+            console.warn('Container ini-params-container não encontrado no DOM.');
+            return;
+        }
+        this.paramsContainer.innerHTML = '';
+        this.inputElements = {};
+
+        INI_CATEGORIES.forEach(cat => {
+            const params = OSKAR_INI_PARAMS.filter(p => p.category === cat.id);
+            if (params.length === 0) return;
+
+            // Wrapper da categoria
+            const catWrapper = document.createElement('div');
+            catWrapper.className = `ini-category ini-category--${cat.id}`;
+
+            // Cabeçalho da categoria
+            const catHeader = document.createElement('div');
+            catHeader.className = 'ini-category__header';
+            catHeader.innerHTML = `<i class="fas ${cat.icon}"></i> <span>${cat.label}</span>`;
+
+            // Corpo (colapsável para avançados)
+            const catBody = document.createElement('div');
+            catBody.className = 'ini-category__body';
+
+            if (cat.collapsible) {
+                catBody.style.display = 'none';
+                const toggleIcon = document.createElement('i');
+                toggleIcon.className = 'fas fa-chevron-down ini-category__toggle';
+                catHeader.appendChild(toggleIcon);
+                catHeader.style.cursor = 'pointer';
+                catHeader.addEventListener('click', () => {
+                    const isHidden = catBody.style.display === 'none';
+                    catBody.style.display = isHidden ? '' : 'none';
+                    toggleIcon.classList.toggle('fa-chevron-down', !isHidden);
+                    toggleIcon.classList.toggle('fa-chevron-up', isHidden);
+                });
+            }
+
+            // Agrupa parâmetros desta categoria por seção
+            const sectionOrder = ['simulator', 'sky', 'observation', 'telescope', 'interferometer'];
+            const grouped = {};
+            params.forEach(p => {
+                if (!grouped[p.section]) grouped[p.section] = [];
+                grouped[p.section].push(p);
+            });
+
+            sectionOrder.forEach(sec => {
+                if (!grouped[sec]) return;
+                const sectionDiv = document.createElement('fieldset');
+                sectionDiv.className = 'ini-section';
+                const legend = document.createElement('legend');
+                legend.textContent = INI_SECTION_LABELS[sec] || sec;
+                sectionDiv.appendChild(legend);
+
+                grouped[sec].forEach(param => {
+                    sectionDiv.appendChild(this._createParamRow(param));
+                });
+
+                catBody.appendChild(sectionDiv);
+            });
+
+            catWrapper.appendChild(catHeader);
+            catWrapper.appendChild(catBody);
+            this.paramsContainer.appendChild(catWrapper);
+        });
+    }
+
+    /**
+     * Cria a linha de input para um parâmetro individual.
+     * @private
+     * @param {Object} param Definição do parâmetro.
+     * @returns {HTMLElement}
+     */
+    _createParamRow(param) {
+        const row = document.createElement('div');
+        row.className = 'ini-param-row';
+        if (param.required) row.classList.add('ini-param-row--required');
+
+        // Label
+        const label = document.createElement('label');
+        const inputId = `ini-input-${param.section}-${param.key.replace(/[/.]/g, '_')}`;
+        label.setAttribute('for', inputId);
+        label.textContent = param.label;
+        if (param.required) {
+            const req = document.createElement('span');
+            req.className = 'ini-required-mark';
+            req.textContent = ' *';
+            label.appendChild(req);
+        }
+
+        // Tooltip
+        const tooltipIcon = document.createElement('i');
+        tooltipIcon.className = 'fas fa-question-circle ini-tooltip-icon';
+        tooltipIcon.title = param.tooltip;
+        label.appendChild(tooltipIcon);
+
+        // Input
+        let input;
+        if (param.type === 'select' && param.options) {
+            input = document.createElement('select');
+            param.options.forEach(opt => {
+                const option = document.createElement('option');
+                option.value = opt.value;
+                option.textContent = opt.label;
+                if (String(opt.value) === String(param.defaultValue)) option.selected = true;
+                input.appendChild(option);
+            });
+        } else if (param.type === 'checkbox') {
+            input = document.createElement('input');
+            input.type = 'checkbox';
+            input.checked = !!param.defaultValue;
+        } else {
+            input = document.createElement('input');
+            input.type = param.type === 'number' ? 'number' : 'text';
+            if (param.type === 'number') input.step = 'any';
+            input.value = param.defaultValue !== undefined ? param.defaultValue : '';
+        }
+
+        input.id = inputId;
+        input.className = 'ini-param-input';
+        input.dataset.iniKey = param.key;
+        input.dataset.iniSection = param.section;
+
+        // Atualiza preview ao alterar valor
+        input.addEventListener('change', () => this.updatePreview());
+        input.addEventListener('input', () => this.updatePreview());
+
+        // Mensagem de erro inline
+        const errorSpan = document.createElement('span');
+        errorSpan.className = 'ini-field-error';
+
+        // Armazena referência
+        const compositeKey = `${param.section}.${param.key}`;
+        this.inputElements[compositeKey] = input;
+
+        row.appendChild(label);
+        row.appendChild(input);
+        row.appendChild(errorSpan);
+        return row;
+    }
+
+    // =========================================================================
+    // Geração do conteúdo INI
+    // =========================================================================
+
+    /**
+     * Gera o conteúdo completo do arquivo .ini a partir dos valores atuais.
+     * @returns {string} Conteúdo formatado do arquivo .ini.
+     */
+    generateIni() {
+        const sections = {};
+
+        OSKAR_INI_PARAMS.forEach(param => {
+            const compositeKey = `${param.section}.${param.key}`;
+            const input = this.inputElements[compositeKey];
+            if (!input) return;
+
+            let value;
+            if (param.type === 'checkbox') {
+                value = input.checked ? 'true' : 'false';
+            } else {
+                value = input.value;
+            }
+
+            // Omite parâmetros com valor vazio (não obrigatórios)
+            if (value === '' && !param.required) return;
+
+            if (!sections[param.section]) sections[param.section] = [];
+            sections[param.section].push({ key: param.key, value });
+        });
+
+        // Monta string INI
+        const sectionOrder = ['simulator', 'sky', 'observation', 'telescope', 'interferometer'];
+        const lines = [];
+
+        sectionOrder.forEach(sec => {
+            if (!sections[sec] || sections[sec].length === 0) return;
+            lines.push(`[${sec}]`);
+            sections[sec].forEach(entry => {
+                lines.push(`${entry.key}=${entry.value}`);
+            });
+            lines.push(''); // linha em branco entre seções
+        });
+
+        return lines.join('\n');
+    }
+
+    // =========================================================================
+    // Preview
+    // =========================================================================
+
+    /**
+     * Atualiza o textarea de pré-visualização com o conteúdo INI atual.
+     */
+    updatePreview() {
+        if (!this.previewTextarea) return;
+        this.previewTextarea.value = this.generateIni();
+    }
+
+    // =========================================================================
+    // Validação
+    // =========================================================================
+
+    /**
+     * Valida todos os campos e exibe mensagens de erro.
+     * @returns {boolean} true se todos os campos estão válidos.
+     */
+    validateFields() {
+        const errors = [];
+        let allValid = true;
+
+        OSKAR_INI_PARAMS.forEach(param => {
+            const compositeKey = `${param.section}.${param.key}`;
+            const input = this.inputElements[compositeKey];
+            if (!input) return;
+
+            const row = input.closest('.ini-param-row');
+            const errorSpan = row ? row.querySelector('.ini-field-error') : null;
+            let errorMsg = '';
+
+            const value = (param.type === 'checkbox') ? input.checked : input.value;
+
+            // Campo obrigatório vazio
+            if (param.required && (value === '' || value === null || value === undefined)) {
+                errorMsg = 'Campo obrigatório.';
+            }
+
+            // Validação numérica
+            if (!errorMsg && param.type === 'number' && value !== '') {
+                const num = Number(value);
+                if (isNaN(num)) {
+                    errorMsg = 'Valor numérico inválido.';
+                }
+            }
+
+            // Validações cruzadas
+            if (!errorMsg) {
+                errorMsg = this._crossValidate(param, value);
+            }
+
+            if (errorMsg) {
+                allValid = false;
+                errors.push({ label: param.label, section: param.section, message: errorMsg });
+                if (input.classList) input.classList.add('ini-input--error');
+            } else {
+                if (input.classList) input.classList.remove('ini-input--error');
+            }
+
+            if (errorSpan) errorSpan.textContent = errorMsg;
+        });
+
+        // Mostra resumo de validação
+        if (this.validationContainer) {
+            if (errors.length === 0) {
+                this.validationContainer.innerHTML = '<span class="ini-validation-ok"><i class="fas fa-check-circle"></i> Todos os campos estão válidos.</span>';
+            } else {
+                const listHtml = errors.map(e =>
+                    `<li><strong>[${INI_SECTION_LABELS[e.section] || e.section}] ${e.label}:</strong> ${e.message}</li>`
+                ).join('');
+                this.validationContainer.innerHTML =
+                    `<span class="ini-validation-error"><i class="fas fa-exclamation-triangle"></i> ${errors.length} problema(s) encontrado(s):</span>` +
+                    `<ul class="ini-validation-list">${listHtml}</ul>`;
+            }
+        }
+
+        return allValid;
+    }
+
+    /**
+     * Realiza validações cruzadas entre campos dependentes.
+     * @private
+     * @param {Object} param Definição do parâmetro sendo validado.
+     * @param {*} value Valor atual do campo.
+     * @returns {string} Mensagem de erro ou string vazia se válido.
+     */
+    _crossValidate(param, value) {
+        // Frequência deve ser positiva
+        if (param.key === 'start_frequency_hz' && value !== '') {
+            if (Number(value) <= 0) return 'A frequência deve ser um valor positivo.';
+        }
+
+        // Número de canais >= 1
+        if (param.key === 'num_channels' && value !== '') {
+            if (Number(value) < 1) return 'Deve haver pelo menos 1 canal.';
+        }
+
+        // Incremento de frequência positivo quando há múltiplos canais
+        if (param.key === 'frequency_inc_hz' && value !== '') {
+            const numChannelsInput = this.inputElements['observation.num_channels'];
+            if (numChannelsInput && Number(numChannelsInput.value) > 1 && Number(value) <= 0) {
+                return 'O incremento deve ser positivo quando há múltiplos canais.';
+            }
+        }
+
+        // Duração e passos de tempo devem ser positivos
+        if (param.key === 'length' && value !== '') {
+            if (Number(value) <= 0) return 'A duração deve ser positiva.';
+        }
+        if (param.key === 'num_time_steps' && value !== '') {
+            if (Number(value) < 1) return 'Deve haver pelo menos 1 passo de tempo.';
+        }
+
+        // Declinação no intervalo válido
+        if (param.key === 'phase_centre_dec_deg' && value !== '') {
+            const dec = Number(value);
+            if (dec < -90 || dec > 90) return 'A declinação deve estar entre -90° e +90°.';
+        }
+
+        return '';
+    }
+
+    // =========================================================================
+    // Preenchimento automático a partir do layout
+    // =========================================================================
+
+    /**
+     * Preenche os campos do telescópio a partir dos dados do layout/mapa atuais.
+     */
+    fillFromLayout() {
+        // Longitude e latitude do BINGO
+        const lonInput = this.inputElements['telescope.longitude_deg'];
+        const latInput = this.inputElements['telescope.latitude_deg'];
+
+        if (lonInput) { lonInput.value = INI_BINGO_LONGITUDE; }
+        if (latInput) { latInput.value = INI_BINGO_LATITUDE; }
+
+        // Tenta obter o diretório de exportação se disponível
+        const dirInput = this.inputElements['telescope.input_dir'];
+        if (dirInput && !dirInput.value) {
+            dirInput.value = 'telescope';
+        }
+
+        // Declinação aproximada = latitude
+        const decInput = this.inputElements['observation.phase_centre_dec_deg'];
+        if (decInput) {
+            decInput.value = INI_BINGO_LATITUDE;
+        }
+
+        // Frequência padrão do BINGO
+        const freqInput = this.inputElements['observation.start_frequency_hz'];
+        if (freqInput && !freqInput.value) {
+            freqInput.value = 980000000;
+        }
+
+        this.updatePreview();
+        console.log('Campos preenchidos a partir dos dados do layout BINGO.');
+    }
+
+    // =========================================================================
+    // Download e cópia
+    // =========================================================================
+
+    /**
+     * Faz o download do arquivo .ini gerado.
+     */
+    downloadIni() {
+        if (!this.validateFields()) {
+            console.warn('Download cancelado: há campos com erros de validação.');
+            return;
+        }
+
+        const content = this.generateIni();
+        const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = 'oskar_sim.ini';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+
+        console.log('Arquivo .ini baixado com sucesso.');
+    }
+
+    /**
+     * Copia o conteúdo INI para a área de transferência.
+     */
+    copyIni() {
+        const content = this.generateIni();
+        const copyBtn = document.getElementById('ini-copy-btn');
+
+        if (!navigator.clipboard) {
+            // Fallback para navegadores mais antigos (execCommand é deprecated, mas necessário como fallback)
+            try {
+                if (this.previewTextarea) {
+                    this.previewTextarea.select();
+                    document.execCommand('copy');
+                }
+                this._showCopyFeedback(copyBtn, true, 'Copiado (legado)!');
+            } catch (err) {
+                console.error('Fallback de cópia falhou:', err);
+                this._showCopyFeedback(copyBtn, false, 'Falha ao copiar.');
+            }
+            return;
+        }
+
+        navigator.clipboard.writeText(content).then(() => {
+            this._showCopyFeedback(copyBtn, true, 'Copiado!');
+            console.log('Conteúdo INI copiado para a área de transferência.');
+        }).catch(err => {
+            console.error('Erro ao copiar com Clipboard API:', err);
+            this._showCopyFeedback(copyBtn, false, 'Erro ao copiar.');
+        });
+    }
+
+    /**
+     * Mostra feedback visual no botão de cópia.
+     * @private
+     * @param {HTMLButtonElement|null} button Botão alvo.
+     * @param {boolean} success Indica sucesso.
+     * @param {string} message Mensagem de title.
+     */
+    _showCopyFeedback(button, success, message) {
+        if (!button) return;
+        const icon = button.querySelector('i');
+        if (!icon) return;
+
+        const originalClass = 'fa-copy';
+        const feedbackClass = success ? 'fa-check' : 'fa-times';
+        const feedbackColor = success ? 'var(--success-color)' : 'var(--secondary-color)';
+
+        icon.classList.remove(originalClass);
+        icon.classList.add(feedbackClass);
+        button.style.color = feedbackColor;
+        button.title = message;
+
+        setTimeout(() => {
+            icon.classList.remove(feedbackClass);
+            icon.classList.add(originalClass);
+            button.style.color = '';
+            button.title = 'Copiar para a área de transferência';
+        }, 1500);
+    }
+}
+
+// =============================================================================
+// Inicialização
+// =============================================================================
+
+document.addEventListener('DOMContentLoaded', () => {
+    if (!window.oskarIniGenerator) {
+        try {
+            window.oskarIniGenerator = new OskarIniGenerator();
+            console.log('Instância de OskarIniGenerator criada e configurada.');
+        } catch (error) {
+            console.error('Erro ao instanciar OskarIniGenerator:', error);
+        }
+    } else {
+        window.oskarIniGenerator.updatePreview();
+    }
+});

From c24bac91ed5955ce55f16ec0ecb71f6f7577acf0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:29:35 +0000
Subject: [PATCH 05/22] Add Sky Model Generator module (js/sky_model.js)

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/sky_model.js | 797 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 797 insertions(+)
 create mode 100644 js/sky_model.js

diff --git a/js/sky_model.js b/js/sky_model.js
new file mode 100644
index 0000000..38f991b
--- /dev/null
+++ b/js/sky_model.js
@@ -0,0 +1,797 @@
+/**
+ * sky_model.js
+ *
+ * @fileoverview Módulo gerador de modelos de céu (sky model) para o simulador OSKAR.
+ *
+ * @description Permite ao usuário criar modelos de céu com fontes pontuais e
+ * estendidas, suportando modos simples e avançado. Modos de geração incluem:
+ * fonte única, grade (grid), aleatório e distribuição power-law. O resultado
+ * é exportado no formato de sky model do OSKAR.
+ *
+ * @requires BingoConstants
+ * @author Geovanni Fernandes Garcia
+ * @version 1.0.2
+ */
+
+'use strict';
+
+// Frequência de referência padrão - usar BingoConstants quando disponível
+const SKY_DEFAULT_REF_FREQ = (typeof BingoConstants !== 'undefined') ? BingoConstants.FREQUENCY_HZ : 1e9;
+
+// =============================================================================
+// Classe principal
+// =============================================================================
+
+class SkyModelGenerator {
+    constructor() {
+        /** @type {Array<Object>} Lista de fontes do modelo de céu */
+        this.sources = [];
+
+        /** @type {string} Modo atual: 'simple' ou 'advanced' */
+        this.mode = 'simple';
+
+        /** @type {string} Tipo de geração: 'single', 'grid', 'random', 'power_law' */
+        this.generationType = 'single';
+
+        // Referências DOM
+        /** @type {HTMLSelectElement|null} */
+        this.modeSelect = document.getElementById('sky-mode-select');
+        /** @type {HTMLSelectElement|null} */
+        this.generationTypeSelect = document.getElementById('sky-generation-type');
+        /** @type {HTMLElement|null} */
+        this.paramsContainer = document.getElementById('sky-params-container');
+        /** @type {HTMLElement|null} */
+        this.sourceTable = document.getElementById('sky-source-table');
+        /** @type {HTMLElement|null} */
+        this.sourceCount = document.getElementById('sky-source-count');
+        /** @type {HTMLTextAreaElement|null} */
+        this.previewTextarea = document.getElementById('sky-preview');
+        /** @type {HTMLButtonElement|null} */
+        this.addBtn = document.getElementById('sky-add-btn');
+        /** @type {HTMLButtonElement|null} */
+        this.clearBtn = document.getElementById('sky-clear-btn');
+        /** @type {HTMLButtonElement|null} */
+        this.downloadBtn = document.getElementById('sky-download-btn');
+        /** @type {HTMLButtonElement|null} */
+        this.copyBtn = document.getElementById('sky-copy-btn');
+
+        this._bindEvents();
+        this.renderControls();
+        this.updatePreview();
+
+        console.log('SkyModelGenerator inicializado com sucesso.');
+    }
+
+    // =========================================================================
+    // Inicialização e bindagem de eventos
+    // =========================================================================
+
+    /**
+     * Liga os event listeners aos elementos da interface.
+     */
+    _bindEvents() {
+        if (this.modeSelect) {
+            this.modeSelect.addEventListener('change', () => {
+                this.mode = this.modeSelect.value;
+                this.renderControls();
+            });
+        }
+
+        if (this.generationTypeSelect) {
+            this.generationTypeSelect.addEventListener('change', () => {
+                this.generationType = this.generationTypeSelect.value;
+                this.renderControls();
+            });
+        }
+
+        if (this.addBtn) {
+            this.addBtn.addEventListener('click', (e) => {
+                e.preventDefault();
+                this._handleAdd();
+            });
+        }
+
+        if (this.clearBtn) {
+            this.clearBtn.addEventListener('click', (e) => {
+                e.preventDefault();
+                this.clearSources();
+            });
+        }
+
+        if (this.downloadBtn) {
+            this.downloadBtn.addEventListener('click', (e) => {
+                e.preventDefault();
+                this.downloadModel();
+            });
+        }
+
+        if (this.copyBtn) {
+            this.copyBtn.addEventListener('click', (e) => {
+                e.preventDefault();
+                this._copyToClipboard();
+            });
+        }
+    }
+
+    // =========================================================================
+    // Renderização de controles
+    // =========================================================================
+
+    /**
+     * Renderiza os controles de parâmetros de acordo com o modo e tipo de geração.
+     */
+    renderControls() {
+        if (!this.paramsContainer) return;
+
+        if (this.mode === 'simple') {
+            this._renderSimpleControls();
+        } else {
+            this._renderAdvancedControls();
+        }
+    }
+
+    /**
+     * Renderiza os controles do modo simples, baseando-se no tipo de geração.
+     */
+    _renderSimpleControls() {
+        let html = '';
+
+        switch (this.generationType) {
+            case 'single':
+                html = this._buildSingleSourceFields();
+                break;
+            case 'grid':
+                html = this._buildGridFields();
+                break;
+            case 'random':
+                html = this._buildRandomFields();
+                break;
+            case 'power_law':
+                html = this._buildPowerLawFields();
+                break;
+            default:
+                html = this._buildSingleSourceFields();
+        }
+
+        this.paramsContainer.innerHTML = html;
+    }
+
+    /**
+     * Renderiza os controles do modo avançado.
+     */
+    _renderAdvancedControls() {
+        this.paramsContainer.innerHTML = `
+            <div class="param-group">
+                <label for="sky-advanced-text">Lista de fontes (formato OSKAR):</label>
+                <textarea id="sky-advanced-text" rows="10" class="form-control"
+                    placeholder="RA(deg) Dec(deg) I(Jy) Q U V freq0(Hz) spix e_maj(arcsec) e_min(arcsec) e_pa(deg)"></textarea>
+                <small class="form-text">Cole fontes no formato OSKAR, uma por linha.</small>
+            </div>
+        `;
+    }
+
+    /**
+     * Gera o HTML dos campos para fonte única.
+     * @returns {string} HTML dos campos.
+     */
+    _buildSingleSourceFields() {
+        return `
+            <div class="param-group">
+                <label for="sky-ra">RA (graus):</label>
+                <input type="number" id="sky-ra" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-dec">Dec (graus):</label>
+                <input type="number" id="sky-dec" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-flux">Fluxo Stokes I (Jy):</label>
+                <input type="number" id="sky-flux" value="1.0" step="0.01" min="0" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-spix">Índice espectral:</label>
+                <input type="number" id="sky-spix" value="0.0" step="0.01" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-ref-freq">Frequência de referência (Hz):</label>
+                <input type="number" id="sky-ref-freq" value="${SKY_DEFAULT_REF_FREQ}" step="1e6" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-major">Eixo maior (arcsec):</label>
+                <input type="number" id="sky-major" value="0.0" step="0.1" min="0" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-minor">Eixo menor (arcsec):</label>
+                <input type="number" id="sky-minor" value="0.0" step="0.1" min="0" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-pa">Ângulo de posição (graus):</label>
+                <input type="number" id="sky-pa" value="0.0" step="0.1" class="form-control">
+            </div>
+        `;
+    }
+
+    /**
+     * Gera o HTML dos campos para geração em grade.
+     * @returns {string} HTML dos campos.
+     */
+    _buildGridFields() {
+        return `
+            <div class="param-group">
+                <label for="sky-grid-n">Dimensão da grade (N×N):</label>
+                <input type="number" id="sky-grid-n" value="5" step="1" min="1" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-grid-spacing">Espaçamento (graus):</label>
+                <input type="number" id="sky-grid-spacing" value="1.0" step="0.01" min="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-grid-ra">RA central (graus):</label>
+                <input type="number" id="sky-grid-ra" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-grid-dec">Dec central (graus):</label>
+                <input type="number" id="sky-grid-dec" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-grid-flux">Fluxo por fonte (Jy):</label>
+                <input type="number" id="sky-grid-flux" value="1.0" step="0.01" min="0" class="form-control">
+            </div>
+        `;
+    }
+
+    /**
+     * Gera o HTML dos campos para geração aleatória.
+     * @returns {string} HTML dos campos.
+     */
+    _buildRandomFields() {
+        return `
+            <div class="param-group">
+                <label for="sky-rand-n">Número de fontes:</label>
+                <input type="number" id="sky-rand-n" value="100" step="1" min="1" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-rand-ra">RA central (graus):</label>
+                <input type="number" id="sky-rand-ra" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-rand-dec">Dec central (graus):</label>
+                <input type="number" id="sky-rand-dec" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-rand-radius">Raio do campo (graus):</label>
+                <input type="number" id="sky-rand-radius" value="5.0" step="0.1" min="0.01" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-rand-flux-min">Fluxo mínimo (Jy):</label>
+                <input type="number" id="sky-rand-flux-min" value="0.01" step="0.001" min="0" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-rand-flux-max">Fluxo máximo (Jy):</label>
+                <input type="number" id="sky-rand-flux-max" value="10.0" step="0.1" min="0" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-rand-spix-min">Índice espectral mín.:</label>
+                <input type="number" id="sky-rand-spix-min" value="-1.0" step="0.1" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-rand-spix-max">Índice espectral máx.:</label>
+                <input type="number" id="sky-rand-spix-max" value="0.0" step="0.1" class="form-control">
+            </div>
+        `;
+    }
+
+    /**
+     * Gera o HTML dos campos para distribuição power-law.
+     * @returns {string} HTML dos campos.
+     */
+    _buildPowerLawFields() {
+        return `
+            <div class="param-group">
+                <label for="sky-pl-n">Número de fontes:</label>
+                <input type="number" id="sky-pl-n" value="200" step="1" min="1" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-pl-ra">RA central (graus):</label>
+                <input type="number" id="sky-pl-ra" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-pl-dec">Dec central (graus):</label>
+                <input type="number" id="sky-pl-dec" value="0.0" step="0.001" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-pl-radius">Raio do campo (graus):</label>
+                <input type="number" id="sky-pl-radius" value="5.0" step="0.1" min="0.01" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-pl-smin">S_min (Jy):</label>
+                <input type="number" id="sky-pl-smin" value="0.001" step="0.0001" min="0" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-pl-smax">S_max (Jy):</label>
+                <input type="number" id="sky-pl-smax" value="10.0" step="0.1" min="0" class="form-control">
+            </div>
+            <div class="param-group">
+                <label for="sky-pl-alpha">Expoente α:</label>
+                <input type="number" id="sky-pl-alpha" value="1.6" step="0.1" min="0.01" class="form-control">
+            </div>
+        `;
+    }
+
+    // =========================================================================
+    // Manipulação de fontes
+    // =========================================================================
+
+    /**
+     * Gerencia o clique no botão de adicionar, despachando para o método correto.
+     */
+    _handleAdd() {
+        if (this.mode === 'advanced') {
+            this._parseAdvancedInput();
+            return;
+        }
+
+        switch (this.generationType) {
+            case 'single':
+                this._addSingleFromUI();
+                break;
+            case 'grid':
+                this._generateGridFromUI();
+                break;
+            case 'random':
+                this._generateRandomFromUI();
+                break;
+            case 'power_law':
+                this._generatePowerLawFromUI();
+                break;
+        }
+    }
+
+    /**
+     * Lê os campos da UI e adiciona uma fonte única.
+     */
+    _addSingleFromUI() {
+        const ra = parseFloat(document.getElementById('sky-ra')?.value) || 0;
+        const dec = parseFloat(document.getElementById('sky-dec')?.value) || 0;
+        const flux = parseFloat(document.getElementById('sky-flux')?.value) || 1;
+        const spix = parseFloat(document.getElementById('sky-spix')?.value) || 0;
+        const refFreq = parseFloat(document.getElementById('sky-ref-freq')?.value) || SKY_DEFAULT_REF_FREQ;
+        const major = parseFloat(document.getElementById('sky-major')?.value) || 0;
+        const minor = parseFloat(document.getElementById('sky-minor')?.value) || 0;
+        const pa = parseFloat(document.getElementById('sky-pa')?.value) || 0;
+
+        this.addSingleSource(ra, dec, flux, spix, refFreq, major, minor, pa);
+    }
+
+    /**
+     * Adiciona uma única fonte ao modelo de céu.
+     * @param {number} ra Ascensão reta em graus.
+     * @param {number} dec Declinação em graus.
+     * @param {number} flux Fluxo Stokes I em Jy.
+     * @param {number} spectralIndex Índice espectral.
+     * @param {number} refFreq Frequência de referência em Hz.
+     * @param {number} [major=0] Eixo maior em arcsec.
+     * @param {number} [minor=0] Eixo menor em arcsec.
+     * @param {number} [pa=0] Ângulo de posição em graus.
+     */
+    addSingleSource(ra, dec, flux, spectralIndex, refFreq, major = 0, minor = 0, pa = 0) {
+        this.sources.push({
+            ra: ra,
+            dec: dec,
+            flux: flux,
+            q: 0,
+            u: 0,
+            v: 0,
+            refFreq: refFreq,
+            spectralIndex: spectralIndex,
+            major: major,
+            minor: minor,
+            pa: pa
+        });
+
+        console.log(`SkyModel: Fonte adicionada em RA=${ra}°, Dec=${dec}°, I=${flux} Jy.`);
+        this.updateSourceTable();
+        this.updatePreview();
+    }
+
+    /**
+     * Lê os campos da UI e gera a grade de fontes.
+     */
+    _generateGridFromUI() {
+        const params = {
+            n: parseInt(document.getElementById('sky-grid-n')?.value) || 5,
+            spacing: parseFloat(document.getElementById('sky-grid-spacing')?.value) || 1.0,
+            centerRA: parseFloat(document.getElementById('sky-grid-ra')?.value) || 0,
+            centerDec: parseFloat(document.getElementById('sky-grid-dec')?.value) || 0,
+            flux: parseFloat(document.getElementById('sky-grid-flux')?.value) || 1.0
+        };
+        this.generateGrid(params);
+    }
+
+    /**
+     * Gera uma grade N×N de fontes pontuais.
+     * @param {Object} params Parâmetros da grade.
+     * @param {number} params.n Dimensão da grade (N×N).
+     * @param {number} params.spacing Espaçamento em graus.
+     * @param {number} params.centerRA RA central em graus.
+     * @param {number} params.centerDec Dec central em graus.
+     * @param {number} params.flux Fluxo de cada fonte em Jy.
+     */
+    generateGrid(params) {
+        const { n, spacing, centerRA, centerDec, flux } = params;
+        const offset = (n - 1) / 2;
+
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                const ra = centerRA + (i - offset) * spacing;
+                const dec = centerDec + (j - offset) * spacing;
+                this.sources.push({
+                    ra: ra,
+                    dec: dec,
+                    flux: flux,
+                    q: 0, u: 0, v: 0,
+                    refFreq: SKY_DEFAULT_REF_FREQ,
+                    spectralIndex: 0,
+                    major: 0, minor: 0, pa: 0
+                });
+            }
+        }
+
+        console.log(`SkyModel: Grade ${n}×${n} gerada com ${n * n} fontes.`);
+        this.updateSourceTable();
+        this.updatePreview();
+    }
+
+    /**
+     * Lê os campos da UI e gera fontes aleatórias.
+     */
+    _generateRandomFromUI() {
+        const params = {
+            count: parseInt(document.getElementById('sky-rand-n')?.value) || 100,
+            centerRA: parseFloat(document.getElementById('sky-rand-ra')?.value) || 0,
+            centerDec: parseFloat(document.getElementById('sky-rand-dec')?.value) || 0,
+            radius: parseFloat(document.getElementById('sky-rand-radius')?.value) || 5.0,
+            fluxMin: parseFloat(document.getElementById('sky-rand-flux-min')?.value) || 0.01,
+            fluxMax: parseFloat(document.getElementById('sky-rand-flux-max')?.value) || 10.0,
+            spixMin: parseFloat(document.getElementById('sky-rand-spix-min')?.value) || -1.0,
+            spixMax: parseFloat(document.getElementById('sky-rand-spix-max')?.value) || 0.0
+        };
+        this.generateRandom(params);
+    }
+
+    /**
+     * Gera fontes aleatórias dentro de um campo circular.
+     * @param {Object} params Parâmetros de geração.
+     * @param {number} params.count Número de fontes.
+     * @param {number} params.centerRA RA central em graus.
+     * @param {number} params.centerDec Dec central em graus.
+     * @param {number} params.radius Raio do campo em graus.
+     * @param {number} params.fluxMin Fluxo mínimo em Jy.
+     * @param {number} params.fluxMax Fluxo máximo em Jy.
+     * @param {number} params.spixMin Índice espectral mínimo.
+     * @param {number} params.spixMax Índice espectral máximo.
+     */
+    generateRandom(params) {
+        const { count, centerRA, centerDec, radius, fluxMin, fluxMax, spixMin, spixMax } = params;
+
+        for (let i = 0; i < count; i++) {
+            // Distribuição uniforme em disco circular
+            const r = radius * Math.sqrt(Math.random());
+            const theta = 2 * Math.PI * Math.random();
+            const ra = centerRA + r * Math.cos(theta);
+            const dec = centerDec + r * Math.sin(theta);
+            const flux = fluxMin + Math.random() * (fluxMax - fluxMin);
+            const spix = spixMin + Math.random() * (spixMax - spixMin);
+
+            this.sources.push({
+                ra: ra,
+                dec: dec,
+                flux: flux,
+                q: 0, u: 0, v: 0,
+                refFreq: SKY_DEFAULT_REF_FREQ,
+                spectralIndex: spix,
+                major: 0, minor: 0, pa: 0
+            });
+        }
+
+        console.log(`SkyModel: ${count} fontes aleatórias geradas no campo de raio ${radius}°.`);
+        this.updateSourceTable();
+        this.updatePreview();
+    }
+
+    /**
+     * Lê os campos da UI e gera distribuição power-law.
+     */
+    _generatePowerLawFromUI() {
+        const params = {
+            count: parseInt(document.getElementById('sky-pl-n')?.value) || 200,
+            centerRA: parseFloat(document.getElementById('sky-pl-ra')?.value) || 0,
+            centerDec: parseFloat(document.getElementById('sky-pl-dec')?.value) || 0,
+            radius: parseFloat(document.getElementById('sky-pl-radius')?.value) || 5.0,
+            sMin: parseFloat(document.getElementById('sky-pl-smin')?.value) || 0.001,
+            sMax: parseFloat(document.getElementById('sky-pl-smax')?.value) || 10.0,
+            alpha: parseFloat(document.getElementById('sky-pl-alpha')?.value) || 1.6
+        };
+        this.generatePowerLaw(params);
+    }
+
+    /**
+     * Gera fontes com distribuição de fluxo power-law (dN/dS ∝ S^{-α}).
+     * @param {Object} params Parâmetros da distribuição.
+     * @param {number} params.count Número de fontes.
+     * @param {number} params.centerRA RA central em graus.
+     * @param {number} params.centerDec Dec central em graus.
+     * @param {number} params.radius Raio do campo em graus.
+     * @param {number} params.sMin Fluxo mínimo em Jy.
+     * @param {number} params.sMax Fluxo máximo em Jy.
+     * @param {number} params.alpha Expoente da power-law.
+     */
+    generatePowerLaw(params) {
+        const { count, centerRA, centerDec, radius, sMin, sMax, alpha } = params;
+        const exponent = 1 - alpha;
+
+        for (let i = 0; i < count; i++) {
+            // Amostragem por inversão da CDF: S = (u * (Smax^e - Smin^e) + Smin^e)^(1/e)
+            const u = Math.random();
+            let flux;
+            if (Math.abs(exponent) < 1e-10) {
+                flux = sMin * Math.pow(sMax / sMin, u);
+            } else {
+                const sMinE = Math.pow(sMin, exponent);
+                const sMaxE = Math.pow(sMax, exponent);
+                flux = Math.pow(u * (sMaxE - sMinE) + sMinE, 1 / exponent);
+            }
+
+            // Posição aleatória no campo
+            const r = radius * Math.sqrt(Math.random());
+            const theta = 2 * Math.PI * Math.random();
+            const ra = centerRA + r * Math.cos(theta);
+            const dec = centerDec + r * Math.sin(theta);
+
+            this.sources.push({
+                ra: ra,
+                dec: dec,
+                flux: flux,
+                q: 0, u: 0, v: 0,
+                refFreq: SKY_DEFAULT_REF_FREQ,
+                spectralIndex: 0,
+                major: 0, minor: 0, pa: 0
+            });
+        }
+
+        console.log(`SkyModel: ${count} fontes power-law geradas (α=${alpha}, S=[${sMin}, ${sMax}] Jy).`);
+        this.updateSourceTable();
+        this.updatePreview();
+    }
+
+    /**
+     * Analisa o texto do modo avançado e importa as fontes.
+     */
+    _parseAdvancedInput() {
+        const textarea = document.getElementById('sky-advanced-text');
+        if (!textarea) return;
+
+        const lines = textarea.value.trim().split('\n');
+        let imported = 0;
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) continue;
+
+            const parts = trimmed.split(/\s+/);
+            if (parts.length < 3) continue;
+
+            this.sources.push({
+                ra: parseFloat(parts[0]) || 0,
+                dec: parseFloat(parts[1]) || 0,
+                flux: parseFloat(parts[2]) || 0,
+                q: parseFloat(parts[3]) || 0,
+                u: parseFloat(parts[4]) || 0,
+                v: parseFloat(parts[5]) || 0,
+                refFreq: parseFloat(parts[6]) || SKY_DEFAULT_REF_FREQ,
+                spectralIndex: parseFloat(parts[7]) || 0,
+                major: parseFloat(parts[8]) || 0,
+                minor: parseFloat(parts[9]) || 0,
+                pa: parseFloat(parts[10]) || 0
+            });
+            imported++;
+        }
+
+        console.log(`SkyModel: ${imported} fontes importadas do modo avançado.`);
+        this.updateSourceTable();
+        this.updatePreview();
+    }
+
+    /**
+     * Remove todas as fontes do modelo.
+     */
+    clearSources() {
+        this.sources = [];
+        console.log('SkyModel: Todas as fontes removidas.');
+        this.updateSourceTable();
+        this.updatePreview();
+    }
+
+    // =========================================================================
+    // Atualização da interface
+    // =========================================================================
+
+    /**
+     * Atualiza a pré-visualização do sky model no textarea.
+     */
+    updatePreview() {
+        if (this.previewTextarea) {
+            this.previewTextarea.value = this.exportOskarFormat();
+        }
+        if (this.sourceCount) {
+            this.sourceCount.textContent = `${this.sources.length} fonte(s)`;
+        }
+    }
+
+    /**
+     * Atualiza a tabela de fontes na interface.
+     */
+    updateSourceTable() {
+        if (!this.sourceTable) return;
+
+        if (this.sources.length === 0) {
+            this.sourceTable.innerHTML = '<tr><td colspan="6" style="text-align:center;">Nenhuma fonte adicionada.</td></tr>';
+            return;
+        }
+
+        let html = `
+            <tr>
+                <th>#</th>
+                <th>RA (°)</th>
+                <th>Dec (°)</th>
+                <th>I (Jy)</th>
+                <th>Índ. Esp.</th>
+                <th>Ação</th>
+            </tr>
+        `;
+
+        this.sources.forEach((src, idx) => {
+            html += `
+                <tr>
+                    <td>${idx + 1}</td>
+                    <td>${src.ra.toFixed(4)}</td>
+                    <td>${src.dec.toFixed(4)}</td>
+                    <td>${src.flux.toFixed(4)}</td>
+                    <td>${src.spectralIndex.toFixed(2)}</td>
+                    <td><button class="sky-remove-btn" data-index="${idx}" title="Remover fonte">✕</button></td>
+                </tr>
+            `;
+        });
+
+        this.sourceTable.innerHTML = html;
+
+        // Liga eventos de remoção individual
+        this.sourceTable.querySelectorAll('.sky-remove-btn').forEach(btn => {
+            btn.addEventListener('click', (e) => {
+                const index = parseInt(e.target.dataset.index);
+                this._removeSource(index);
+            });
+        });
+    }
+
+    /**
+     * Remove uma fonte pelo índice.
+     * @param {number} index Índice da fonte a remover.
+     */
+    _removeSource(index) {
+        if (index >= 0 && index < this.sources.length) {
+            this.sources.splice(index, 1);
+            console.log(`SkyModel: Fonte #${index + 1} removida.`);
+            this.updateSourceTable();
+            this.updatePreview();
+        }
+    }
+
+    // =========================================================================
+    // Exportação
+    // =========================================================================
+
+    /**
+     * Gera o texto no formato sky model do OSKAR.
+     * Cada linha: RA(deg) Dec(deg) I(Jy) Q U V freq0(Hz) spix e_maj(arcsec) e_min(arcsec) e_pa(deg)
+     * @returns {string} Conteúdo do sky model.
+     */
+    exportOskarFormat() {
+        const lines = [];
+
+        lines.push(`# OSKAR Sky Model`);
+        lines.push(`# Gerado pelo BINGO Layout Generator`);
+        lines.push(`# Número de fontes: ${this.sources.length}`);
+        lines.push(`# Formato: RA(deg) Dec(deg) I(Jy) Q U V freq0(Hz) spix e_maj(arcsec) e_min(arcsec) e_pa(deg)`);
+
+        for (const src of this.sources) {
+            const parts = [
+                src.ra.toFixed(6),
+                src.dec.toFixed(6),
+                src.flux.toExponential(6),
+                src.q.toFixed(1),
+                src.u.toFixed(1),
+                src.v.toFixed(1),
+                src.refFreq.toExponential(6),
+                src.spectralIndex.toFixed(4),
+                src.major.toFixed(2),
+                src.minor.toFixed(2),
+                src.pa.toFixed(2)
+            ];
+            lines.push(parts.join(' '));
+        }
+
+        return lines.join('\n');
+    }
+
+    /**
+     * Faz o download do arquivo sky model (.osm).
+     */
+    downloadModel() {
+        const content = this.exportOskarFormat();
+        const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+        const url = URL.createObjectURL(blob);
+
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = 'bingo_sky_model.osm';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+
+        console.log('SkyModel: Arquivo sky model baixado com sucesso.');
+    }
+
+    /**
+     * Copia o conteúdo do sky model para a área de transferência.
+     */
+    _copyToClipboard() {
+        const content = this.exportOskarFormat();
+
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+            navigator.clipboard.writeText(content).then(() => {
+                console.log('SkyModel: Conteúdo copiado para a área de transferência.');
+                this._showCopyFeedback();
+            }).catch(err => {
+                console.error('SkyModel: Erro ao copiar para a área de transferência:', err);
+            });
+        } else if (this.previewTextarea) {
+            this.previewTextarea.select();
+            document.execCommand('copy');
+            console.log('SkyModel: Conteúdo copiado (método legado).');
+            this._showCopyFeedback();
+        }
+    }
+
+    /**
+     * Mostra feedback visual temporário no botão de copiar.
+     */
+    _showCopyFeedback() {
+        if (!this.copyBtn) return;
+        const originalText = this.copyBtn.innerHTML;
+        this.copyBtn.innerHTML = '<i class="fas fa-check"></i> Copiado!';
+        this.copyBtn.disabled = true;
+        setTimeout(() => {
+            this.copyBtn.innerHTML = originalText;
+            this.copyBtn.disabled = false;
+        }, 1500);
+    }
+}
+
+// =============================================================================
+// Inicialização
+// =============================================================================
+
+document.addEventListener('DOMContentLoaded', () => {
+    if (!window.skyModelGenerator) {
+        try {
+            window.skyModelGenerator = new SkyModelGenerator();
+            console.log('Instância de SkyModelGenerator criada e configurada.');
+        } catch (error) {
+            console.error('Erro ao instanciar SkyModelGenerator:', error);
+        }
+    } else {
+        window.skyModelGenerator.updatePreview();
+    }
+});

From 14bc23793a59a53df96ccb776fa6d408c4a03750 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:33:35 +0000
Subject: [PATCH 06/22] Add UV Coverage Visualization module
 (js/uv_coverage.js)

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/uv_coverage.js | 393 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 393 insertions(+)
 create mode 100644 js/uv_coverage.js

diff --git a/js/uv_coverage.js b/js/uv_coverage.js
new file mode 100644
index 0000000..64a77fc
--- /dev/null
+++ b/js/uv_coverage.js
@@ -0,0 +1,393 @@
+/**
+ * uv_coverage.js
+ *
+ * @fileoverview Módulo de simulação e visualização da cobertura UV para o BINGO Layout Generator.
+ * Calcula coordenadas UV para todos os pares de estações (baselines) em função do ângulo horário
+ * e plota a cobertura UV utilizando Plotly.js.
+ *
+ * @description Para cada par de estações, calcula componentes u,v a partir dos vetores de baseline
+ * e parâmetros de observação (declinação, duração, frequência). Suporta exportação do gráfico
+ * e cálculo automático da resolução angular (θ ≈ λ/D_max).
+ *
+ * @requires BingoConstants
+ * @requires Plotly
+ * @author Geovanni Fernandes Garcia
+ * @version 1.0.2
+ */
+
+'use strict';
+
+class UVCoverageSimulator {
+    constructor() {
+        // IDs dos elementos da UI
+        this.decInputId = 'uv-dec-input';
+        this.durationInputId = 'uv-duration-input';
+        this.timestepsInputId = 'uv-timesteps-input';
+        this.freqInputId = 'uv-freq-input';
+        this.latitudeInputId = 'uv-latitude-input';
+        this.generateBtnId = 'uv-generate-btn';
+        this.plotContainerId = 'uv-plot-container';
+        this.resolutionDisplayId = 'uv-resolution-display';
+        this.exportBtnId = 'uv-export-btn';
+        this.statusId = 'uv-status';
+
+        // Referências aos elementos DOM
+        this.decInput = document.getElementById(this.decInputId);
+        this.durationInput = document.getElementById(this.durationInputId);
+        this.timestepsInput = document.getElementById(this.timestepsInputId);
+        this.freqInput = document.getElementById(this.freqInputId);
+        this.latitudeInput = document.getElementById(this.latitudeInputId);
+        this.generateBtn = document.getElementById(this.generateBtnId);
+        this.plotContainer = document.getElementById(this.plotContainerId);
+        this.resolutionDisplay = document.getElementById(this.resolutionDisplayId);
+        this.exportBtn = document.getElementById(this.exportBtnId);
+        this.statusDisplay = document.getElementById(this.statusId);
+
+        // Parâmetros padrão
+        this.defaultDec = -7.04;
+        this.defaultDuration = 4;
+        this.defaultTimesteps = 60;
+        this.defaultFreqMHz = (BingoConstants.FREQUENCY_HZ / 1e6);
+        this.defaultLatitude = BingoConstants.BINGO_LATITUDE;
+
+        // Dados UV armazenados
+        this.uvData = null;
+
+        this._initUI();
+        this._bindEvents();
+
+        console.log("UVCoverageSimulator: Módulo de cobertura UV inicializado.");
+    }
+
+    /**
+     * Inicializa valores padrão nos campos da UI.
+     * @private
+     */
+    _initUI() {
+        if (this.decInput) this.decInput.value = this.defaultDec;
+        if (this.durationInput) this.durationInput.value = this.defaultDuration;
+        if (this.timestepsInput) this.timestepsInput.value = this.defaultTimesteps;
+        if (this.freqInput) this.freqInput.value = this.defaultFreqMHz;
+        if (this.latitudeInput) this.latitudeInput.value = this.defaultLatitude;
+    }
+
+    /**
+     * Vincula eventos aos elementos da UI e escuta eventos globais.
+     * @private
+     */
+    _bindEvents() {
+        if (this.generateBtn) {
+            this.generateBtn.addEventListener('click', () => this.generateUVCoverage());
+        }
+        if (this.exportBtn) {
+            this.exportBtn.addEventListener('click', () => this.exportPlot('png'));
+        }
+
+        // Escuta evento de estações geradas para atualização automática
+        window.addEventListener('stationsGenerated', () => {
+            const uvTab = document.querySelector('.tab-button[data-tab="uv-coverage"]') ||
+                          document.querySelector('[data-tab="uv-coverage"]');
+            const isActive = uvTab && uvTab.classList.contains('active');
+            if (isActive) {
+                console.log("UVCoverageSimulator: Evento 'stationsGenerated' recebido. Atualizando cobertura UV.");
+                this.generateUVCoverage();
+            }
+        });
+    }
+
+    /**
+     * Obtém as posições atuais das estações.
+     * @returns {Array<{x: number, y: number}>} Array de posições de estações.
+     */
+    getStationPositions() {
+        if (window.stationManager && typeof window.stationManager.getStationPositions === 'function') {
+            return window.stationManager.getStationPositions();
+        }
+        if (window.interactiveMap && typeof window.interactiveMap.getStationPositions === 'function') {
+            return window.interactiveMap.getStationPositions();
+        }
+        console.warn("UVCoverageSimulator: Nenhuma fonte de posições de estações encontrada.");
+        return [];
+    }
+
+    /**
+     * Lê os parâmetros de observação da UI ou retorna valores padrão.
+     * @returns {{dec: number, duration: number, timesteps: number, freqHz: number, latitude: number}}
+     * @private
+     */
+    _readParams() {
+        const dec = this.decInput ? parseFloat(this.decInput.value) : this.defaultDec;
+        const duration = this.durationInput ? parseFloat(this.durationInput.value) : this.defaultDuration;
+        const timesteps = this.timestepsInput ? parseInt(this.timestepsInput.value, 10) : this.defaultTimesteps;
+        const freqMHz = this.freqInput ? parseFloat(this.freqInput.value) : this.defaultFreqMHz;
+        const latitude = this.latitudeInput ? parseFloat(this.latitudeInput.value) : this.defaultLatitude;
+
+        return {
+            dec: isNaN(dec) ? this.defaultDec : dec,
+            duration: isNaN(duration) ? this.defaultDuration : duration,
+            timesteps: isNaN(timesteps) || timesteps < 1 ? this.defaultTimesteps : timesteps,
+            freqHz: isNaN(freqMHz) ? BingoConstants.FREQUENCY_HZ : freqMHz * 1e6,
+            latitude: isNaN(latitude) ? this.defaultLatitude : latitude
+        };
+    }
+
+    /**
+     * Calcula a cobertura UV para todos os pares de estações e passos de tempo.
+     * Para cada baseline, calcula u,v como função do ângulo horário.
+     *
+     * u = Bx*sin(H) + By*cos(H)
+     * v = -Bx*sin(dec)*cos(H) + By*sin(dec)*sin(H) + Bz*cos(dec)
+     *
+     * Bx, By são componentes do baseline no plano local (Bz = 0 para estações coplanares).
+     * Coordenadas em comprimentos de onda: u_λ = u/λ, v_λ = v/λ.
+     */
+    generateUVCoverage() {
+        const stations = this.getStationPositions();
+        if (!stations || stations.length < 2) {
+            this.updateStatus("Erro: São necessárias pelo menos 2 estações para calcular a cobertura UV.");
+            console.error("UVCoverageSimulator: Número insuficiente de estações.");
+            return;
+        }
+
+        this.updateStatus("Calculando cobertura UV...");
+
+        const params = this._readParams();
+        const decRad = params.dec * BingoConstants.DEG_TO_RAD;
+        const latRad = params.latitude * BingoConstants.DEG_TO_RAD;
+        const lambda = BingoConstants.SPEED_OF_LIGHT / params.freqHz;
+
+        const sinDec = Math.sin(decRad);
+        const cosDec = Math.cos(decRad);
+        const sinLat = Math.sin(latRad);
+        const cosLat = Math.cos(latRad);
+
+        // Ângulos horários: centrados em 0, de -duration/2 a +duration/2
+        const halfDuration = params.duration / 2;
+        const hourAngles = [];
+        for (let i = 0; i < params.timesteps; i++) {
+            const hHours = -halfDuration + (params.duration * i) / (params.timesteps > 1 ? params.timesteps - 1 : 1);
+            // Converter horas para radianos (1h = 15°)
+            hourAngles.push(hHours * 15 * BingoConstants.DEG_TO_RAD);
+        }
+
+        const uPoints = [];
+        const vPoints = [];
+        const baselineLengths = [];
+        let maxBaseline = 0;
+
+        const nStations = stations.length;
+
+        for (let i = 0; i < nStations; i++) {
+            for (let j = i + 1; j < nStations; j++) {
+                // Componentes do baseline no plano local (ENU: East, North, Up)
+                const Bx = stations[j].x - stations[i].x; // East
+                const By = stations[j].y - stations[i].y; // North
+                const Bz = 0; // Estações coplanares
+
+                const bLen = Math.sqrt(Bx * Bx + By * By);
+                if (bLen > maxBaseline) maxBaseline = bLen;
+
+                for (let t = 0; t < hourAngles.length; t++) {
+                    const H = hourAngles[t];
+                    const sinH = Math.sin(H);
+                    const cosH = Math.cos(H);
+
+                    const u = Bx * sinH + By * cosH;
+                    const v = -Bx * sinDec * cosH + By * sinDec * sinH + Bz * cosDec;
+
+                    const uLambda = u / lambda;
+                    const vLambda = v / lambda;
+
+                    // Ponto original
+                    uPoints.push(uLambda);
+                    vPoints.push(vLambda);
+                    baselineLengths.push(bLen);
+
+                    // Ponto conjugado (-u, -v)
+                    uPoints.push(-uLambda);
+                    vPoints.push(-vLambda);
+                    baselineLengths.push(bLen);
+                }
+            }
+        }
+
+        this.uvData = { uPoints, vPoints, baselineLengths, maxBaseline, lambda, params };
+
+        const nBaselines = (nStations * (nStations - 1)) / 2;
+        console.log(`UVCoverageSimulator: ${nBaselines} baselines calculadas, ${uPoints.length} pontos UV gerados.`);
+
+        this.plotUVCoverage(this.uvData);
+        this.calculateResolution();
+        this.updateStatus(`Cobertura UV gerada: ${nBaselines} baselines, ${uPoints.length} pontos.`);
+    }
+
+    /**
+     * Plota a cobertura UV usando Plotly.js com mapa de cores por comprimento de baseline.
+     * @param {Object} uvData - Dados UV calculados.
+     * @param {number[]} uvData.uPoints - Coordenadas u em comprimentos de onda.
+     * @param {number[]} uvData.vPoints - Coordenadas v em comprimentos de onda.
+     * @param {number[]} uvData.baselineLengths - Comprimento de cada baseline (metros).
+     * @param {number} uvData.maxBaseline - Baseline máxima (metros).
+     * @param {number} uvData.lambda - Comprimento de onda (metros).
+     */
+    plotUVCoverage(uvData) {
+        if (!this.plotContainer) {
+            console.warn("UVCoverageSimulator: Contêiner do gráfico não encontrado.");
+            return;
+        }
+        if (typeof Plotly === 'undefined') {
+            console.error("UVCoverageSimulator: Plotly.js não está carregado.");
+            this.updateStatus("Erro: Plotly.js não encontrado.");
+            return;
+        }
+
+        const { uPoints, vPoints, baselineLengths, maxBaseline, lambda } = uvData;
+
+        const resArcmin = maxBaseline > 0
+            ? (lambda / maxBaseline) * BingoConstants.RAD_TO_DEG * 60
+            : 0;
+
+        const trace = {
+            x: uPoints,
+            y: vPoints,
+            mode: 'markers',
+            type: 'scatter',
+            marker: {
+                size: 2,
+                color: baselineLengths,
+                colorscale: [
+                    [0, 'rgb(0,0,255)'],
+                    [0.5, 'rgb(0,200,0)'],
+                    [1, 'rgb(255,0,0)']
+                ],
+                colorbar: {
+                    title: 'Baseline (m)',
+                    titleside: 'right'
+                },
+                opacity: 0.6
+            },
+            hovertemplate: 'u: %{x:.1f} λ<br>v: %{y:.1f} λ<br>Baseline: %{marker.color:.1f} m<extra></extra>'
+        };
+
+        const layout = {
+            title: 'Cobertura UV',
+            xaxis: {
+                title: 'u (comprimentos de onda)',
+                scaleanchor: 'y',
+                scaleratio: 1,
+                zeroline: true,
+                zerolinecolor: '#888'
+            },
+            yaxis: {
+                title: 'v (comprimentos de onda)',
+                zeroline: true,
+                zerolinecolor: '#888'
+            },
+            hovermode: 'closest',
+            plot_bgcolor: '#1a1a2e',
+            paper_bgcolor: '#16213e',
+            font: { color: '#e0e0e0' },
+            annotations: [{
+                x: 0.02,
+                y: 0.98,
+                xref: 'paper',
+                yref: 'paper',
+                text: `Baseline máx: ${maxBaseline.toFixed(1)} m | Resolução: ${resArcmin.toFixed(2)} arcmin`,
+                showarrow: false,
+                font: { size: 11, color: '#aaa' },
+                bgcolor: 'rgba(0,0,0,0.5)',
+                borderpad: 4
+            }],
+            margin: { t: 50, b: 60, l: 60, r: 20 }
+        };
+
+        const config = {
+            responsive: true,
+            displayModeBar: true,
+            modeBarButtonsToRemove: ['lasso2d', 'select2d']
+        };
+
+        Plotly.newPlot(this.plotContainer, [trace], layout, config);
+    }
+
+    /**
+     * Calcula e exibe a resolução angular a partir da baseline máxima.
+     * θ ≈ λ / D_max (em radianos), convertido para arcminutos.
+     */
+    calculateResolution() {
+        if (!this.uvData || this.uvData.maxBaseline <= 0) {
+            if (this.resolutionDisplay) {
+                this.resolutionDisplay.textContent = 'Resolução: N/A';
+            }
+            return;
+        }
+
+        const { maxBaseline, lambda } = this.uvData;
+        const thetaRad = lambda / maxBaseline;
+        const thetaDeg = thetaRad * BingoConstants.RAD_TO_DEG;
+        const thetaArcmin = thetaDeg * 60;
+        const thetaArcsec = thetaArcmin * 60;
+
+        let displayText;
+        if (thetaArcmin >= 1) {
+            displayText = `Resolução angular: ${thetaArcmin.toFixed(2)} arcmin (θ ≈ λ/D_max)`;
+        } else {
+            displayText = `Resolução angular: ${thetaArcsec.toFixed(2)} arcsec (θ ≈ λ/D_max)`;
+        }
+
+        if (this.resolutionDisplay) {
+            this.resolutionDisplay.textContent = displayText;
+        }
+
+        console.log(`UVCoverageSimulator: Baseline máx = ${maxBaseline.toFixed(2)} m, λ = ${lambda.toFixed(4)} m, resolução = ${thetaArcmin.toFixed(4)} arcmin.`);
+    }
+
+    /**
+     * Exporta o gráfico UV como imagem PNG ou SVG.
+     * @param {string} [format='png'] - Formato de exportação ('png' ou 'svg').
+     */
+    exportPlot(format = 'png') {
+        if (!this.plotContainer) {
+            this.updateStatus("Erro: Contêiner do gráfico não encontrado para exportação.");
+            return;
+        }
+        if (typeof Plotly === 'undefined') {
+            this.updateStatus("Erro: Plotly.js não encontrado.");
+            return;
+        }
+
+        const validFormat = (format === 'svg') ? 'svg' : 'png';
+
+        Plotly.downloadImage(this.plotContainer, {
+            format: validFormat,
+            width: 1200,
+            height: 1000,
+            filename: `bingo_uv_coverage_${Date.now()}`
+        }).then(() => {
+            this.updateStatus(`Gráfico UV exportado como ${validFormat.toUpperCase()}.`);
+            console.log(`UVCoverageSimulator: Gráfico exportado como ${validFormat.toUpperCase()}.`);
+        }).catch((err) => {
+            this.updateStatus("Erro ao exportar gráfico UV.");
+            console.error("UVCoverageSimulator: Erro na exportação:", err);
+        });
+    }
+
+    /**
+     * Atualiza a mensagem de status na UI.
+     * @param {string} msg - Mensagem de status.
+     */
+    updateStatus(msg) {
+        if (this.statusDisplay) {
+            this.statusDisplay.textContent = msg;
+        }
+    }
+}
+
+// Inicialização e exposição global
+if (typeof window !== 'undefined') {
+    document.addEventListener('DOMContentLoaded', () => {
+        if (!window.uvCoverageSimulator) {
+            window.uvCoverageSimulator = new UVCoverageSimulator();
+        }
+    });
+}

From 87fff1a7ed074de3e030668491209a82c40a71f5 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:37:23 +0000
Subject: [PATCH 07/22] Add tab system, station manager, OSKAR INI generator,
 sky model generator, and UV coverage modules

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css | 497 +++++++++++++++++++++++++++++++++++++++++++++++++
 index.html     | 234 +++++++++++++++++++++++
 js/main.js     |  69 ++++++-
 3 files changed, 796 insertions(+), 4 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index 97db595..d9f1f33 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -771,6 +771,503 @@ label.file-input-label[for="import-config-input"].secondary {
 /* Rodapé */
 footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-color); color: var(--header-text-color); margin-top: 30px; }
 
+/* ==================== Sistema de Abas ==================== */
+.tab-navigation {
+    display: flex;
+    gap: 4px;
+    margin-bottom: 20px;
+    border-bottom: 2px solid var(--border-color);
+    padding-bottom: 0;
+    flex-wrap: wrap;
+}
+.tab-btn {
+    padding: 12px 20px;
+    border: 1px solid transparent;
+    border-bottom: none;
+    border-radius: 8px 8px 0 0;
+    background-color: var(--highlight-color);
+    color: var(--text-color);
+    font-weight: 500;
+    font-size: 0.95em;
+    cursor: pointer;
+    transition: background-color 0.2s, color 0.2s, border-color 0.2s;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    white-space: nowrap;
+}
+.tab-btn:hover {
+    background-color: var(--highlight-hover-color);
+}
+.tab-btn.active {
+    background-color: var(--card-bg-color);
+    color: var(--primary-color);
+    border-color: var(--border-color);
+    border-bottom: 2px solid var(--card-bg-color);
+    margin-bottom: -2px;
+    font-weight: 600;
+}
+.tab-btn i {
+    font-size: 1em;
+}
+.tab-content {
+    display: none;
+}
+.tab-content.active {
+    display: block;
+}
+
+/* ==================== Gerador de Stations ==================== */
+.station-generator-section {
+    background-color: var(--card-bg-color);
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 10px var(--shadow-color);
+    margin-bottom: 20px;
+}
+.station-generator-section h2 {
+    margin-bottom: 15px;
+    text-align: center;
+}
+.station-controls-row {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 20px;
+}
+.station-controls-panel {
+    flex: 1;
+    min-width: 280px;
+    max-width: 400px;
+}
+.station-stats-panel {
+    flex: 2;
+    min-width: 300px;
+    display: flex;
+    flex-wrap: wrap;
+    gap: 15px;
+    align-content: flex-start;
+}
+.info-box {
+    background-color: var(--highlight-color);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 12px 15px;
+    flex: 1;
+    min-width: 180px;
+}
+.info-box h3 {
+    font-size: 0.95em;
+    margin-bottom: 8px;
+    color: var(--primary-color);
+}
+.highlight-box {
+    border-color: var(--primary-color);
+    background-color: rgba(52, 152, 219, 0.05);
+}
+[data-theme="dark"] .highlight-box {
+    background-color: rgba(139, 233, 253, 0.05);
+}
+.stat-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 6px;
+}
+.stat-item {
+    font-size: 0.9em;
+}
+.stat-label {
+    font-weight: 500;
+    opacity: 0.8;
+}
+.baseline-short { color: #3498db; }
+.baseline-long { color: #e74c3c; }
+[data-theme="dark"] .baseline-short { color: #8be9fd; }
+[data-theme="dark"] .baseline-long { color: #ff79c6; }
+.resolution-values {
+    text-align: center;
+}
+.resolution-main {
+    font-size: 1.3em;
+    font-weight: 700;
+    color: var(--primary-color);
+    margin: 4px 0;
+}
+.resolution-sub {
+    font-size: 0.9em;
+    opacity: 0.8;
+}
+.slider-hint {
+    display: block;
+    font-size: 0.75em;
+    opacity: 0.6;
+    margin-top: 3px;
+}
+
+/* ==================== Barra de Atalhos Rápidos ==================== */
+.quick-access-bar {
+    display: flex;
+    gap: 10px;
+    justify-content: center;
+    flex-wrap: wrap;
+    padding: 15px;
+    background-color: var(--card-bg-color);
+    border-radius: 8px;
+    box-shadow: 0 2px 10px var(--shadow-color);
+    margin-top: 20px;
+}
+.quick-btn {
+    padding: 10px 18px;
+    background-color: var(--highlight-color);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    color: var(--text-color);
+    font-weight: 500;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    transition: background-color 0.2s, border-color 0.2s;
+}
+.quick-btn:hover {
+    background-color: var(--highlight-hover-color);
+    border-color: var(--primary-color);
+}
+
+/* ==================== Gerador INI (.ini) ==================== */
+.ini-generator-section {
+    background-color: var(--card-bg-color);
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 10px var(--shadow-color);
+}
+.section-description {
+    text-align: center;
+    margin-bottom: 20px;
+    opacity: 0.8;
+    font-size: 0.95em;
+}
+.section-description code {
+    background-color: var(--highlight-color);
+    padding: 2px 6px;
+    border-radius: 3px;
+    font-size: 0.9em;
+}
+.ini-layout {
+    display: flex;
+    gap: 20px;
+    flex-wrap: wrap;
+}
+.ini-params-area {
+    flex: 3;
+    min-width: 400px;
+}
+.ini-preview-area {
+    flex: 2;
+    min-width: 300px;
+    display: flex;
+    flex-direction: column;
+}
+.ini-toolbar {
+    margin-bottom: 15px;
+}
+.ini-params-container {
+    max-height: 600px;
+    overflow-y: auto;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 15px;
+    background-color: var(--bg-color);
+}
+.ini-section-group {
+    margin-bottom: 20px;
+}
+.ini-section-title {
+    font-weight: 600;
+    font-size: 1.05em;
+    color: var(--primary-color);
+    margin-bottom: 10px;
+    padding-bottom: 5px;
+    border-bottom: 1px solid var(--border-color);
+}
+.ini-category-group {
+    margin-bottom: 15px;
+}
+.ini-category-label {
+    font-size: 0.85em;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 8px;
+    padding: 4px 8px;
+    border-radius: 3px;
+}
+.ini-category-essential { background-color: rgba(231, 76, 60, 0.1); color: #e74c3c; }
+.ini-category-recommended { background-color: rgba(52, 152, 219, 0.1); color: #3498db; }
+.ini-category-advanced { background-color: rgba(149, 165, 166, 0.1); color: #95a5a6; }
+[data-theme="dark"] .ini-category-essential { background-color: rgba(255, 121, 198, 0.15); color: #ff79c6; }
+[data-theme="dark"] .ini-category-recommended { background-color: rgba(139, 233, 253, 0.15); color: #8be9fd; }
+[data-theme="dark"] .ini-category-advanced { background-color: rgba(98, 114, 164, 0.15); color: #6272a4; }
+.ini-param-row {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 8px;
+    padding: 6px 8px;
+    border-radius: 4px;
+    transition: background-color 0.15s;
+}
+.ini-param-row:hover {
+    background-color: var(--highlight-color);
+}
+.ini-param-label {
+    flex: 1;
+    min-width: 180px;
+    font-size: 0.9em;
+    font-weight: 500;
+    cursor: help;
+}
+.ini-param-input {
+    flex: 2;
+    min-width: 200px;
+}
+.ini-param-input input,
+.ini-param-input select {
+    width: 100%;
+    padding: 6px 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background-color: var(--input-bg-color);
+    color: var(--input-text-color);
+    font-size: 0.9em;
+    box-sizing: border-box;
+}
+.ini-param-input input.invalid {
+    border-color: #e74c3c;
+    box-shadow: 0 0 0 2px rgba(231, 76, 60, 0.2);
+}
+.ini-collapsible-toggle {
+    cursor: pointer;
+    padding: 8px;
+    text-align: center;
+    font-size: 0.85em;
+    color: var(--primary-color);
+    border: 1px dashed var(--border-color);
+    border-radius: 4px;
+    margin-top: 10px;
+    transition: background-color 0.2s;
+}
+.ini-collapsible-toggle:hover {
+    background-color: var(--highlight-color);
+}
+.ini-collapsible-content {
+    display: none;
+}
+.ini-collapsible-content.expanded {
+    display: block;
+}
+#ini-preview {
+    flex: 1;
+    min-height: 400px;
+    padding: 12px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-family: monospace;
+    font-size: 12px;
+    resize: vertical;
+    background-color: var(--input-bg-color);
+    color: var(--input-text-color);
+    box-sizing: border-box;
+}
+.ini-actions, .sky-actions {
+    display: flex;
+    gap: 10px;
+    margin-top: 10px;
+    justify-content: flex-end;
+}
+.validation-messages {
+    margin-top: 10px;
+}
+.validation-msg {
+    padding: 6px 10px;
+    border-radius: 4px;
+    font-size: 0.85em;
+    margin-bottom: 4px;
+}
+.validation-msg.error { background-color: rgba(231, 76, 60, 0.1); color: #e74c3c; border-left: 3px solid #e74c3c; }
+.validation-msg.warning { background-color: rgba(243, 156, 18, 0.1); color: #f39c12; border-left: 3px solid #f39c12; }
+[data-theme="dark"] .validation-msg.error { background-color: rgba(255, 121, 198, 0.1); color: #ff79c6; border-left-color: #ff79c6; }
+[data-theme="dark"] .validation-msg.warning { background-color: rgba(241, 250, 140, 0.1); color: #f1fa8c; border-left-color: #f1fa8c; }
+.placeholder-text {
+    text-align: center;
+    padding: 20px;
+    opacity: 0.6;
+    font-style: italic;
+}
+
+/* ==================== Modelo de Céu ==================== */
+.sky-model-section {
+    background-color: var(--card-bg-color);
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 10px var(--shadow-color);
+}
+.sky-model-layout {
+    display: flex;
+    gap: 20px;
+    flex-wrap: wrap;
+}
+.sky-controls-area {
+    flex: 1;
+    min-width: 280px;
+    max-width: 400px;
+}
+.sky-preview-area {
+    flex: 2;
+    min-width: 350px;
+    display: flex;
+    flex-direction: column;
+}
+.sky-params-container {
+    margin-bottom: 15px;
+}
+.sky-source-info {
+    margin-bottom: 10px;
+    font-size: 0.95em;
+}
+.source-table-container {
+    max-height: 250px;
+    overflow-y: auto;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    margin-bottom: 15px;
+}
+.source-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.85em;
+}
+.source-table th,
+.source-table td {
+    padding: 6px 10px;
+    border-bottom: 1px solid var(--border-color);
+    text-align: right;
+}
+.source-table th {
+    background-color: var(--highlight-color);
+    font-weight: 600;
+    text-align: center;
+    position: sticky;
+    top: 0;
+    z-index: 1;
+}
+.source-table .empty-msg {
+    text-align: center;
+    font-style: italic;
+    opacity: 0.6;
+    padding: 20px;
+}
+#sky-preview {
+    flex: 1;
+    min-height: 200px;
+    padding: 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-family: monospace;
+    font-size: 11px;
+    resize: vertical;
+    background-color: var(--input-bg-color);
+    color: var(--input-text-color);
+    box-sizing: border-box;
+}
+
+/* ==================== Cobertura UV ==================== */
+.uv-coverage-section {
+    background-color: var(--card-bg-color);
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 10px var(--shadow-color);
+}
+.uv-layout {
+    display: flex;
+    gap: 20px;
+    flex-wrap: wrap;
+}
+.uv-controls-area {
+    flex: 1;
+    min-width: 260px;
+    max-width: 350px;
+}
+.uv-plot-area {
+    flex: 3;
+    min-width: 400px;
+}
+.uv-plot-container {
+    width: 100%;
+    min-height: 500px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background-color: var(--plot-bg-color);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+.uv-plot-container .plot-placeholder {
+    font-style: italic;
+    opacity: 0.6;
+    text-align: center;
+    padding: 40px;
+}
+
+/* ==================== Status Messages ==================== */
+.status-message {
+    text-align: center;
+    margin-top: 10px;
+    font-style: italic;
+    opacity: 0.8;
+    min-height: 1.2em;
+}
+
+/* ==================== Tab Responsividade ==================== */
+@media (max-width: 768px) {
+    .tab-navigation {
+        gap: 2px;
+    }
+    .tab-btn {
+        padding: 8px 12px;
+        font-size: 0.85em;
+    }
+    .tab-btn i {
+        display: none;
+    }
+    .station-controls-row {
+        flex-direction: column;
+    }
+    .station-controls-panel {
+        max-width: none;
+    }
+    .ini-layout, .sky-model-layout, .uv-layout {
+        flex-direction: column;
+    }
+    .ini-params-area, .sky-controls-area, .uv-controls-area {
+        min-width: unset;
+        max-width: none;
+    }
+    .ini-preview-area, .sky-preview-area, .uv-plot-area {
+        min-width: unset;
+    }
+}
+
+@media (max-width: 480px) {
+    .tab-btn {
+        padding: 6px 8px;
+        font-size: 0.8em;
+        flex: 1;
+        justify-content: center;
+    }
+    .quick-access-bar {
+        flex-direction: column;
+    }
+}
 /* Colisões */
 .collision-info { margin-top: 15px; border: 1px solid var(--border-color); border-radius: 4px; overflow: hidden; background-color: var(--card-bg-color); flex-shrink: 0; }
 .collision-header { padding: 10px 15px; background-color: var(--highlight-color); border-bottom: 1px solid var(--border-color); cursor: pointer; font-weight: 500; display: flex; justify-content: space-between; align-items: center; }
diff --git a/index.html b/index.html
index 7ffca34..c4f67c3 100644
--- a/index.html
+++ b/index.html
@@ -130,6 +130,85 @@ <h1>Gerador de Layouts de Antenas BINGO</h1>
     </header>
 
     <main id="main-content" class="container" role="main">
+        <!-- Navegação por Abas -->
+        <nav class="tab-navigation" role="tablist" aria-label="Seções principais">
+            <button class="tab-btn active" data-tab="tab-layout" role="tab" aria-selected="true" aria-controls="tab-layout">
+                <i class="fas fa-satellite-dish"></i> Layout Principal
+            </button>
+            <button class="tab-btn" data-tab="tab-oskar-config" role="tab" aria-selected="false" aria-controls="tab-oskar-config">
+                <i class="fas fa-cogs"></i> Configuração OSKAR
+            </button>
+            <button class="tab-btn" data-tab="tab-sky-model" role="tab" aria-selected="false" aria-controls="tab-sky-model">
+                <i class="fas fa-star"></i> Modelo de Céu
+            </button>
+            <button class="tab-btn" data-tab="tab-uv-coverage" role="tab" aria-selected="false" aria-controls="tab-uv-coverage">
+                <i class="fas fa-project-diagram"></i> Cobertura UV
+            </button>
+        </nav>
+
+        <!-- === ABA 1: LAYOUT PRINCIPAL === -->
+        <div id="tab-layout" class="tab-content active" role="tabpanel">
+
+        <!-- Gerador de Stations -->
+        <section class="station-generator-section">
+            <h2><i class="fas fa-broadcast-tower"></i> Gerador de Posições de Stations</h2>
+            <div class="station-controls-row">
+                <div class="station-controls-panel">
+                    <div class="form-group">
+                        <label for="station-layout-type">Tipo de Layout:</label>
+                        <select id="station-layout-type">
+                            <option value="grid">Grid Regular</option>
+                            <option value="circular">Circular (Anel)</option>
+                            <option value="spiral">Espiral</option>
+                            <option value="y_shape">Forma em Y</option>
+                            <option value="cross">Cruz</option>
+                            <option value="random">Aleatório</option>
+                        </select>
+                    </div>
+                    <div class="form-group">
+                        <label for="station-count">Número de Stations:</label>
+                        <input type="number" id="station-count" value="7" min="2" max="100" step="1">
+                    </div>
+                    <div class="form-group">
+                        <label for="station-spacing">Espaçamento (m): <span id="station-spacing-value">300</span></label>
+                        <input type="range" id="station-spacing" min="1.2" max="3.5" step="0.01" value="2.48"
+                            title="Escala logarítmica: 15m — 3000m">
+                        <small class="slider-hint">Escala log: 15m — 3km (~30× a escala dos tiles)</small>
+                    </div>
+                    <div class="button-group">
+                        <button id="station-generate-btn" class="primary"><i class="fas fa-sync-alt"></i> Gerar Stations</button>
+                        <button id="station-random-btn" class="secondary"><i class="fas fa-random"></i> Randomizar</button>
+                    </div>
+                </div>
+                <div class="station-stats-panel">
+                    <div id="station-stats" class="info-box">
+                        <h3>Estatísticas do Array</h3>
+                        <div class="stat-grid">
+                            <div class="stat-item"><span class="stat-label">Stations:</span> <span id="stat-station-count">0</span></div>
+                            <div class="stat-item"><span class="stat-label">Baselines:</span> <span id="stat-baseline-count">0</span></div>
+                        </div>
+                    </div>
+                    <div id="angular-resolution-display" class="info-box highlight-box">
+                        <h3><i class="fas fa-crosshairs"></i> Resolução Angular</h3>
+                        <div class="resolution-values">
+                            <div>θ ≈ λ/D<sub>max</sub></div>
+                            <div id="resolution-arcmin" class="resolution-main">-- arcmin</div>
+                            <div id="resolution-arcsec" class="resolution-sub">-- arcsec</div>
+                        </div>
+                    </div>
+                    <div id="baseline-info" class="info-box">
+                        <h3>Baselines</h3>
+                        <div class="stat-grid">
+                            <div class="stat-item"><span class="stat-label">Mín:</span> <span id="baseline-min">--</span></div>
+                            <div class="stat-item"><span class="stat-label">Máx:</span> <span id="baseline-max">--</span></div>
+                            <div class="stat-item baseline-short"><span class="stat-label">Curtas (&lt;50m):</span> <span id="baseline-short-count">0</span></div>
+                            <div class="stat-item baseline-long"><span class="stat-label">Longas (&gt;1km):</span> <span id="baseline-long-count">0</span></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </section>
+
         <div class="generator-beam-row">
             <section class="layout-generator">
                  <h2>Gerador de Layout</h2>
@@ -365,6 +444,156 @@ <h2 id="export-heading">Exportação (Estrutura OSKAR)</h2>
                 <button id="download-zip-btn" class="primary"><i class="fas fa-file-archive" aria-hidden="true"></i> Baixar Layout (ZIP)</button>
             </div>
         </section>
+
+        <!-- Atalhos rápidos -->
+        <div class="quick-access-bar">
+            <button class="quick-btn" data-target="tab-oskar-config"><i class="fas fa-cogs"></i> Gerar .ini</button>
+            <button class="quick-btn" data-target="tab-sky-model"><i class="fas fa-star"></i> Modelo de Céu</button>
+            <button class="quick-btn" data-target="tab-uv-coverage"><i class="fas fa-project-diagram"></i> Cobertura UV</button>
+        </div>
+
+        </div><!-- Fim #tab-layout -->
+
+        <!-- === ABA 2: CONFIGURAÇÃO OSKAR (.ini) === -->
+        <div id="tab-oskar-config" class="tab-content" role="tabpanel">
+            <section class="ini-generator-section">
+                <h2><i class="fas fa-cogs"></i> Gerador de Arquivo de Observação (.ini)</h2>
+                <p class="section-description">Monte o arquivo <code>.ini</code> de configuração do OSKAR. Preencha os parâmetros abaixo — campos essenciais estão destacados. Todos os valores possuem tooltips com a documentação detalhada em PT-BR.</p>
+                <div class="ini-layout">
+                    <div class="ini-params-area">
+                        <div class="ini-toolbar">
+                            <button id="ini-fill-from-layout-btn" class="primary small-btn" title="Preenche os campos do telescópio com os dados do layout e mapa atuais">
+                                <i class="fas fa-magic"></i> Preencher a partir do Layout Atual
+                            </button>
+                        </div>
+                        <div id="ini-params-container" class="ini-params-container">
+                            <!-- Parâmetros renderizados dinamicamente por ini_generator.js -->
+                            <p class="placeholder-text">Carregando parâmetros OSKAR...</p>
+                        </div>
+                        <div id="ini-validation-messages" class="validation-messages"></div>
+                    </div>
+                    <div class="ini-preview-area">
+                        <h3>Preview do arquivo .ini</h3>
+                        <textarea id="ini-preview" readonly placeholder="O conteúdo do arquivo .ini aparecerá aqui..."></textarea>
+                        <div class="ini-actions">
+                            <button id="ini-copy-btn" class="secondary small-btn"><i class="fas fa-copy"></i> Copiar</button>
+                            <button id="ini-download-btn" class="primary small-btn"><i class="fas fa-download"></i> Baixar .ini</button>
+                        </div>
+                    </div>
+                </div>
+            </section>
+        </div><!-- Fim #tab-oskar-config -->
+
+        <!-- === ABA 3: MODELO DE CÉU === -->
+        <div id="tab-sky-model" class="tab-content" role="tabpanel">
+            <section class="sky-model-section">
+                <h2><i class="fas fa-star"></i> Gerador de Modelo de Céu (Sky Model)</h2>
+                <p class="section-description">Crie modelos de céu para simulações OSKAR. Use o modo simples para fontes pontuais e grids, ou o modo avançado para distribuições complexas.</p>
+                <div class="sky-model-layout">
+                    <div class="sky-controls-area">
+                        <div class="form-group">
+                            <label for="sky-mode-select">Modo:</label>
+                            <select id="sky-mode-select">
+                                <option value="simple">Simples</option>
+                                <option value="advanced">Avançado</option>
+                            </select>
+                        </div>
+                        <div class="form-group">
+                            <label for="sky-generation-type">Tipo de Geração:</label>
+                            <select id="sky-generation-type">
+                                <option value="single">Fonte Pontual Individual</option>
+                                <option value="grid">Grid de Fontes</option>
+                                <option value="random">Distribuição Aleatória</option>
+                                <option value="power_law">Distribuição Power-Law</option>
+                            </select>
+                        </div>
+                        <div id="sky-params-container" class="sky-params-container">
+                            <!-- Parâmetros renderizados dinamicamente por sky_model.js -->
+                        </div>
+                        <div class="button-group">
+                            <button id="sky-add-btn" class="primary"><i class="fas fa-plus"></i> Adicionar Fontes</button>
+                            <button id="sky-clear-btn" class="secondary"><i class="fas fa-trash"></i> Limpar Tudo</button>
+                        </div>
+                    </div>
+                    <div class="sky-preview-area">
+                        <div class="sky-source-info">
+                            <span>Total de fontes: <strong id="sky-source-count">0</strong></span>
+                        </div>
+                        <div id="sky-source-table-container" class="source-table-container">
+                            <table id="sky-source-table" class="source-table">
+                                <thead>
+                                    <tr>
+                                        <th>RA (°)</th>
+                                        <th>Dec (°)</th>
+                                        <th>I (Jy)</th>
+                                        <th>Spix</th>
+                                        <th>Freq₀ (Hz)</th>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    <tr><td colspan="5" class="empty-msg">Nenhuma fonte adicionada</td></tr>
+                                </tbody>
+                            </table>
+                        </div>
+                        <h3>Preview (formato OSKAR)</h3>
+                        <textarea id="sky-preview" readonly placeholder="O modelo de céu em formato OSKAR aparecerá aqui..."></textarea>
+                        <div class="sky-actions">
+                            <button id="sky-copy-btn" class="secondary small-btn"><i class="fas fa-copy"></i> Copiar</button>
+                            <button id="sky-download-btn" class="primary small-btn"><i class="fas fa-download"></i> Baixar sky_model.txt</button>
+                        </div>
+                    </div>
+                </div>
+            </section>
+        </div><!-- Fim #tab-sky-model -->
+
+        <!-- === ABA 4: COBERTURA UV === -->
+        <div id="tab-uv-coverage" class="tab-content" role="tabpanel">
+            <section class="uv-coverage-section">
+                <h2><i class="fas fa-project-diagram"></i> Visualização de Cobertura UV</h2>
+                <p class="section-description">Simule e visualize a cobertura UV baseada no arranjo atual e nos parâmetros de observação. Modifique parâmetros para ver o impacto em tempo real.</p>
+                <div class="uv-layout">
+                    <div class="uv-controls-area">
+                        <div class="form-group">
+                            <label for="uv-dec-input">Declinação (°):</label>
+                            <input type="number" id="uv-dec-input" value="-7.04" min="-90" max="90" step="0.01">
+                        </div>
+                        <div class="form-group">
+                            <label for="uv-duration-input">Duração da Observação (h):</label>
+                            <input type="number" id="uv-duration-input" value="4" min="0.1" max="24" step="0.1">
+                        </div>
+                        <div class="form-group">
+                            <label for="uv-timesteps-input">Passos de Tempo:</label>
+                            <input type="number" id="uv-timesteps-input" value="60" min="1" max="1000" step="1">
+                        </div>
+                        <div class="form-group">
+                            <label for="uv-freq-input">Frequência (MHz):</label>
+                            <input type="number" id="uv-freq-input" value="1000" min="1" max="100000" step="1">
+                        </div>
+                        <div class="form-group">
+                            <label for="uv-latitude-input">Latitude do Observatório (°):</label>
+                            <input type="number" id="uv-latitude-input" value="-7.04" min="-90" max="90" step="0.01">
+                        </div>
+                        <div class="button-group">
+                            <button id="uv-generate-btn" class="primary"><i class="fas fa-play"></i> Gerar Cobertura UV</button>
+                            <button id="uv-export-btn" class="secondary"><i class="fas fa-image"></i> Exportar PNG</button>
+                        </div>
+                        <div id="uv-resolution-display" class="info-box highlight-box" style="margin-top: 15px;">
+                            <h3><i class="fas fa-crosshairs"></i> Resolução Angular</h3>
+                            <div id="uv-resolution-text" class="resolution-values">
+                                <div>Gere a cobertura UV para calcular</div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="uv-plot-area">
+                        <div id="uv-plot-container" class="uv-plot-container">
+                            <div class="plot-placeholder">Clique em "Gerar Cobertura UV" para visualizar o diagrama UV do arranjo.</div>
+                        </div>
+                        <div id="uv-status" class="status-message">Aguardando geração...</div>
+                    </div>
+                </div>
+            </section>
+        </div><!-- Fim #tab-uv-coverage -->
+
     </main>
 
     <footer role="contentinfo">
@@ -395,6 +624,11 @@ <h2 id="export-heading">Exportação (Estrutura OSKAR)</h2>
     <script src="js/beam_pattern.js"></script>
     <script src="js/psf_analyzer.js"></script>
     <script src="js/psf_ee_theta_plot.js"></script>
+    <script src="js/tabs.js"></script>
+    <script src="js/stations.js"></script>
+    <script src="js/ini_generator.js"></script>
+    <script src="js/sky_model.js"></script>
+    <script src="js/uv_coverage.js"></script>
     <script src="js/main.js"></script>
 </body>
 </html>
\ No newline at end of file
diff --git a/js/main.js b/js/main.js
index 0f244d3..6aac5a0 100644
--- a/js/main.js
+++ b/js/main.js
@@ -32,22 +32,28 @@ function checkComponentsAndSetup() {
 
      if (!window.BingoLayouts) { missingComponents.push('BingoLayouts'); allComponentsReady = false; }
      if (!window.antennaGenerator) { missingComponents.push('AntennaLayoutGenerator'); allComponentsReady = false; }
-     if (!window.interactiveMap) { missingComponents.push('InteractiveMap'); allComponentsReady = false; }
      if (!window.oskarExporter) { missingComponents.push('OskarLayoutExporter'); allComponentsReady = false; }
      if (!window.psfAnalyzer) { missingComponents.push('PSFAnalyzer'); allComponentsReady = false; }
-     // Adiciona verificação para o novo plotter
      if (!window.psfEeThetaPlotter) { missingComponents.push('PSFEeThetaPlotter'); allComponentsReady = false; }
+     if (!window.tabManager) { missingComponents.push('TabManager'); allComponentsReady = false; }
 
+     // Componentes opcionais (podem falhar por CDN bloqueado)
+     if (!window.interactiveMap) { console.warn('InteractiveMap não disponível (CDN pode estar bloqueado).'); }
+     if (!window.stationManager) { console.warn('StationManager não inicializado.'); }
+     if (!window.oskarIniGenerator) { console.warn('OskarIniGenerator não inicializado.'); }
+     if (!window.skyModelGenerator) { console.warn('SkyModelGenerator não inicializado.'); }
+     if (!window.uvCoverageSimulator) { console.warn('UVCoverageSimulator não inicializado.'); }
 
      if (allComponentsReady) {
          console.log('Todos os componentes principais foram carregados com sucesso!');
          setupGlobalEventListeners();
          setupDarkMode();
+         setupQuickAccessButtons();
 
          if (window.antennaGenerator) {
             console.log("Chamando geração de layout inicial a partir de main.js...");
-            window.antennaGenerator.resizeCanvas(); // Garante que o canvas tenha o tamanho certo
-            window.antennaGenerator.generateLayout(); // Gera o layout inicial
+            window.antennaGenerator.resizeCanvas();
+            window.antennaGenerator.generateLayout();
         }
      } else {
           console.error("Falha na inicialização: Componentes ausentes:", missingComponents);
@@ -183,6 +189,61 @@ function setupGlobalEventListeners() {
     console.log('Listeners globais configurados.');
 }
 
+/**
+ * Configura os botões de acesso rápido na barra de atalhos abaixo do mapa.
+ */
+function setupQuickAccessButtons() {
+    const quickBtns = document.querySelectorAll('.quick-btn[data-target]');
+    quickBtns.forEach(btn => {
+        btn.addEventListener('click', () => {
+            const targetTab = btn.getAttribute('data-target');
+            if (targetTab && window.tabManager) {
+                window.tabManager.switchToTab(targetTab);
+            }
+        });
+    });
+
+    // Listener para evento tabChanged - redimensiona plots ao trocar de aba
+    document.addEventListener('tabChanged', (event) => {
+        const { tabId } = event.detail;
+        console.log(`Main.js: Aba alterada para "${tabId}".`);
+
+        // Redimensiona o canvas do gerador e plots Plotly quando voltar à aba de layout
+        if (tabId === 'tab-layout') {
+            setTimeout(() => {
+                if (window.antennaGenerator?.resizeCanvas) {
+                    window.antennaGenerator.resizeCanvas();
+                }
+                // Redimensiona plots Plotly
+                const plotIds = ['beam-pattern-plot', 'psf-ee-theta-plot'];
+                plotIds.forEach(id => {
+                    const el = document.getElementById(id);
+                    if (el && typeof Plotly !== 'undefined') {
+                        try { Plotly.Plots.resize(el); } catch(e) { /* plot pode não existir */ }
+                    }
+                });
+            }, 100);
+        }
+
+        // Redimensiona o plot UV quando a aba UV é ativada
+        if (tabId === 'tab-uv-coverage') {
+            setTimeout(() => {
+                const uvPlot = document.getElementById('uv-plot-container');
+                if (uvPlot && typeof Plotly !== 'undefined') {
+                    try { Plotly.Plots.resize(uvPlot); } catch(e) { /* plot pode não existir */ }
+                }
+            }, 100);
+        }
+    });
+
+    // Listener para evento stationsGenerated - atualiza módulos dependentes
+    window.addEventListener('stationsGenerated', () => {
+        console.log("Main.js: Evento 'stationsGenerated' recebido.");
+    });
+
+    console.log('Botões de acesso rápido configurados.');
+}
+
 function setupDarkMode() {
     const darkModeToggle = document.getElementById('dark-mode-toggle');
     if (!darkModeToggle) {

From a4544cb7bcf1d89568a149bd21e3ea86d96e9e78 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:39:43 +0000
Subject: [PATCH 08/22] Fix station spacing slider range, fix tab ARIA
 attributes

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 index.html | 2 +-
 js/tabs.js | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/index.html b/index.html
index c4f67c3..8d2e2f6 100644
--- a/index.html
+++ b/index.html
@@ -171,7 +171,7 @@ <h2><i class="fas fa-broadcast-tower"></i> Gerador de Posições de Stations</h2
                     </div>
                     <div class="form-group">
                         <label for="station-spacing">Espaçamento (m): <span id="station-spacing-value">300</span></label>
-                        <input type="range" id="station-spacing" min="1.2" max="3.5" step="0.01" value="2.48"
+                        <input type="range" id="station-spacing" min="0" max="1" step="0.001" value="0.565"
                             title="Escala logarítmica: 15m — 3000m">
                         <small class="slider-hint">Escala log: 15m — 3km (~30× a escala dos tiles)</small>
                     </div>
diff --git a/js/tabs.js b/js/tabs.js
index dc90db0..9944c3e 100644
--- a/js/tabs.js
+++ b/js/tabs.js
@@ -106,11 +106,15 @@ class TabManager {
         const previousTabId = this.activeTabId;
 
         // Remove classe ativa de todos os botões e painéis
-        this.tabButtons.forEach((btn) => btn.classList.remove('active'));
+        this.tabButtons.forEach((btn) => {
+            btn.classList.remove('active');
+            btn.setAttribute('aria-selected', 'false');
+        });
         this.tabPanels.forEach((panel) => panel.classList.remove('active'));
 
         // Ativa o botão e painel selecionados
         targetBtn.classList.add('active');
+        targetBtn.setAttribute('aria-selected', 'true');
         targetPanel.classList.add('active');
 
         this.activeTabId = tabId;

From 6414dcace9aca66da71a750b212f35e0b4154edd Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:41:13 +0000
Subject: [PATCH 09/22] =?UTF-8?q?Add=20ECEF/ENU=20coordinate=20export=20fo?=
 =?UTF-8?q?rmats=20with=20WGS84=E2=86=92ECEF=E2=86=92ENU=20conversion?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css |   2 +-
 index.html     |   8 ++++
 js/export.js   | 110 ++++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 118 insertions(+), 2 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index d9f1f33..7199702 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -620,7 +620,7 @@ button.small-btn {
 }
 .export-container h2 { margin-bottom: 15px; text-align: center; }
 .export-fields {
-    display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px;
+    display: grid; grid-template-columns: repeat(3, 1fr); gap: 15px;
     margin-bottom: 20px;
 }
 .export-field { position: relative; }
diff --git a/index.html b/index.html
index 8d2e2f6..d918409 100644
--- a/index.html
+++ b/index.html
@@ -437,6 +437,14 @@ <h2 id="export-heading">Exportação (Estrutura OSKAR)</h2>
                     <label for="export-tile-layout">station/tile/layout.txt:</label>
                     <textarea id="export-tile-layout" readonly title="Coordenadas XY relativas das 64 antenas no tile"></textarea>
                 </div>
+                 <div class="export-field">
+                    <label for="export-layout-ecef">layout_ecef.txt:</label>
+                    <textarea id="export-layout-ecef" readonly title="Coordenadas ECEF (Earth-Centered Earth-Fixed) das estações"></textarea>
+                </div>
+                 <div class="export-field">
+                    <label for="export-layout-enu">layout_enu.txt:</label>
+                    <textarea id="export-layout-enu" readonly title="Coordenadas ENU (East-North-Up) relativas ao BINGO Central"></textarea>
+                </div>
             </div>
             <div class="download-zip-group">
                 <label for="zip-filename-input" class="sr-only">Nome do arquivo ZIP</label>
diff --git a/js/export.js b/js/export.js
index d1a9b82..745b14f 100644
--- a/js/export.js
+++ b/js/export.js
@@ -88,7 +88,9 @@ class OskarLayoutExporter {
             'export-layout-wgs84',
             'export-position',
             'export-station-layout',
-            'export-tile-layout'
+            'export-tile-layout',
+            'export-layout-ecef',
+            'export-layout-enu'
         ];
         textareaIds.forEach(id => this._addSingleCopyButtonToTextarea(id));
     }
@@ -217,6 +219,8 @@ class OskarLayoutExporter {
         // this.updateBingoPositionField(); // Já chamado no construtor, é fixo.
         this.updateStationLayoutField();
         // this.updateTileLayoutField(); // Já chamado no construtor e generateSingleTileLayout, é fixo.
+        this.updateLayoutEcefField();
+        this.updateLayoutEnuField();
         
         console.log("Campos de exportação OSKAR atualizados com os dados mais recentes.");
     }
@@ -296,6 +300,102 @@ class OskarLayoutExporter {
              return '';
         }).filter(line => line).join('\n');
     }
+
+    // --- Conversões de Coordenadas (WGS84 → ECEF → ENU) ---
+
+    /**
+     * Converte coordenadas WGS84 (lat, lon, alt) para ECEF (X, Y, Z).
+     * @param {number} latDeg Latitude em graus
+     * @param {number} lonDeg Longitude em graus
+     * @param {number} altM Altitude em metros
+     * @returns {{x: number, y: number, z: number}} Coordenadas ECEF em metros
+     */
+    wgs84ToEcef(latDeg, lonDeg, altM) {
+        const a = 6378137.0; // WGS84 semi-eixo maior
+        const f = 1.0 / 298.257223563; // WGS84 achatamento
+        const e2 = 2 * f - f * f; // excentricidade ao quadrado
+
+        const latRad = latDeg * Math.PI / 180;
+        const lonRad = lonDeg * Math.PI / 180;
+        const sinLat = Math.sin(latRad);
+        const cosLat = Math.cos(latRad);
+        const sinLon = Math.sin(lonRad);
+        const cosLon = Math.cos(lonRad);
+
+        const N = a / Math.sqrt(1 - e2 * sinLat * sinLat);
+
+        return {
+            x: (N + altM) * cosLat * cosLon,
+            y: (N + altM) * cosLat * sinLon,
+            z: (N * (1 - e2) + altM) * sinLat
+        };
+    }
+
+    /**
+     * Converte coordenadas ECEF para ENU relativas a um ponto de referência.
+     * @param {number} x ECEF X
+     * @param {number} y ECEF Y
+     * @param {number} z ECEF Z
+     * @param {number} refLatDeg Latitude de referência em graus
+     * @param {number} refLonDeg Longitude de referência em graus
+     * @param {number} refAltM Altitude de referência em metros
+     * @returns {{e: number, n: number, u: number}} Coordenadas ENU em metros
+     */
+    ecefToEnu(x, y, z, refLatDeg, refLonDeg, refAltM) {
+        const ref = this.wgs84ToEcef(refLatDeg, refLonDeg, refAltM);
+        const dx = x - ref.x;
+        const dy = y - ref.y;
+        const dz = z - ref.z;
+
+        const latRad = refLatDeg * Math.PI / 180;
+        const lonRad = refLonDeg * Math.PI / 180;
+        const sinLat = Math.sin(latRad);
+        const cosLat = Math.cos(latRad);
+        const sinLon = Math.sin(lonRad);
+        const cosLon = Math.cos(lonRad);
+
+        return {
+            e: -sinLon * dx + cosLon * dy,
+            n: -sinLat * cosLon * dx - sinLat * sinLon * dy + cosLat * dz,
+            u: cosLat * cosLon * dx + cosLat * sinLon * dy + sinLat * dz
+        };
+    }
+
+    /**
+     * Atualiza o textarea para layout_ecef.txt (Coordenadas ECEF das estações).
+     */
+    updateLayoutEcefField() {
+        const textarea = document.getElementById('export-layout-ecef');
+        if (!textarea) return;
+
+        if (!this.selectedStationsCoords || this.selectedStationsCoords.length === 0) {
+            textarea.value = 'Nenhuma estação selecionada.\nGere stations primeiro.';
+            return;
+        }
+        textarea.value = this.selectedStationsCoords.map(station => {
+            const ecef = this.wgs84ToEcef(station.lat || 0, station.lon || 0, station.alt || 0);
+            return `${ecef.x.toFixed(4)},${ecef.y.toFixed(4)},${ecef.z.toFixed(4)}`;
+        }).join('\n');
+    }
+
+    /**
+     * Atualiza o textarea para layout_enu.txt (Coordenadas ENU relativas ao BINGO Central).
+     */
+    updateLayoutEnuField() {
+        const textarea = document.getElementById('export-layout-enu');
+        if (!textarea) return;
+
+        if (!this.selectedStationsCoords || this.selectedStationsCoords.length === 0) {
+            textarea.value = 'Nenhuma estação selecionada.\nGere stations primeiro.';
+            return;
+        }
+        textarea.value = this.selectedStationsCoords.map(station => {
+            const ecef = this.wgs84ToEcef(station.lat || 0, station.lon || 0, station.alt || 0);
+            const enu = this.ecefToEnu(ecef.x, ecef.y, ecef.z,
+                BINGO_CENTRAL_LATITUDE, BINGO_CENTRAL_LONGITUDE, BINGO_CENTRAL_ALTITUDE);
+            return `${enu.e.toFixed(4)},${enu.n.toFixed(4)},${enu.u.toFixed(4)}`;
+        }).join('\n');
+    }
 } // Fim da classe OskarLayoutExporter
 
 // --- Inicialização da Exportação e Funcionalidade de Download ZIP ---
@@ -350,10 +450,18 @@ document.addEventListener('DOMContentLoaded', () => {
                 const contentPosition = document.getElementById('export-position').value;
                 const contentStationLayout = document.getElementById('export-station-layout').value;
                 const contentTileLayout = document.getElementById('export-tile-layout').value;
+                const contentEcef = document.getElementById('export-layout-ecef')?.value || '';
+                const contentEnu = document.getElementById('export-layout-enu')?.value || '';
 
                 // Adiciona os arquivos ao ZIP com a estrutura de diretórios OSKAR.
                 zip.file("layout_wgs84.txt", contentWGS84);
                 zip.file("position.txt", contentPosition);
+                if (contentEcef && !contentEcef.startsWith('Nenhuma')) {
+                    zip.file("layout_ecef.txt", contentEcef);
+                }
+                if (contentEnu && !contentEnu.startsWith('Nenhuma')) {
+                    zip.file("layout_enu.txt", contentEnu);
+                }
                 const stationFolder = zip.folder("station"); // Cria pasta "station"
                 stationFolder.file("layout.txt", contentStationLayout);
                 const tileFolder = stationFolder.folder("tile"); // Cria pasta "station/tile"

From 6ef49fb8893a226491ccdd7b2d1b363aa66440eb Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 21:42:48 +0000
Subject: [PATCH 10/22] Address code review: fix UV single timestep, improve
 CSS contrast, document optional components

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css    | 2 +-
 js/main.js        | 4 ++--
 js/uv_coverage.js | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index 7199702..c560f07 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -1003,7 +1003,7 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
 }
 .ini-category-essential { background-color: rgba(231, 76, 60, 0.1); color: #e74c3c; }
 .ini-category-recommended { background-color: rgba(52, 152, 219, 0.1); color: #3498db; }
-.ini-category-advanced { background-color: rgba(149, 165, 166, 0.1); color: #95a5a6; }
+.ini-category-advanced { background-color: rgba(127, 140, 141, 0.1); color: #566573; }
 [data-theme="dark"] .ini-category-essential { background-color: rgba(255, 121, 198, 0.15); color: #ff79c6; }
 [data-theme="dark"] .ini-category-recommended { background-color: rgba(139, 233, 253, 0.15); color: #8be9fd; }
 [data-theme="dark"] .ini-category-advanced { background-color: rgba(98, 114, 164, 0.15); color: #6272a4; }
diff --git a/js/main.js b/js/main.js
index 6aac5a0..74937a6 100644
--- a/js/main.js
+++ b/js/main.js
@@ -37,8 +37,8 @@ function checkComponentsAndSetup() {
      if (!window.psfEeThetaPlotter) { missingComponents.push('PSFEeThetaPlotter'); allComponentsReady = false; }
      if (!window.tabManager) { missingComponents.push('TabManager'); allComponentsReady = false; }
 
-     // Componentes opcionais (podem falhar por CDN bloqueado)
-     if (!window.interactiveMap) { console.warn('InteractiveMap não disponível (CDN pode estar bloqueado).'); }
+     // Componentes opcionais (podem falhar por CDN bloqueado - Leaflet, Plotly)
+     if (!window.interactiveMap) { console.warn('InteractiveMap não disponível (CDN Leaflet pode estar bloqueado).'); }
      if (!window.stationManager) { console.warn('StationManager não inicializado.'); }
      if (!window.oskarIniGenerator) { console.warn('OskarIniGenerator não inicializado.'); }
      if (!window.skyModelGenerator) { console.warn('SkyModelGenerator não inicializado.'); }
diff --git a/js/uv_coverage.js b/js/uv_coverage.js
index 64a77fc..85de8b4 100644
--- a/js/uv_coverage.js
+++ b/js/uv_coverage.js
@@ -165,7 +165,7 @@ class UVCoverageSimulator {
         const halfDuration = params.duration / 2;
         const hourAngles = [];
         for (let i = 0; i < params.timesteps; i++) {
-            const hHours = -halfDuration + (params.duration * i) / (params.timesteps > 1 ? params.timesteps - 1 : 1);
+            const hHours = params.timesteps === 1 ? 0 : -halfDuration + (params.duration * i) / (params.timesteps - 1);
             // Converter horas para radianos (1h = 15°)
             hourAngles.push(hHours * 15 * BingoConstants.DEG_TO_RAD);
         }

From 828d80da377b11334982d513e46e0e900e685bba Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 22:17:05 +0000
Subject: [PATCH 11/22] Implement UV plot fix, station-map layout,
 station-to-map integration, and enhanced station parameters

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css    | 127 +++++++++++++----
 index.html        | 146 +++++++++----------
 js/stations.js    | 353 +++++++++++++++++++++++++++++++++++++---------
 js/uv_coverage.js |  25 +++-
 4 files changed, 482 insertions(+), 169 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index c560f07..938f9ac 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -580,7 +580,7 @@ button.small-btn {
 }
 
 
-/* Estilos para o mapa interativo */
+/* Estilos para o mapa interativo (agora dentro da station-map-row) */
 .map-container {
     margin-bottom: 30px; background-color: var(--card-bg-color);
     border-radius: 8px; padding: 20px; box-shadow: 0 2px 10px var(--shadow-color);
@@ -589,21 +589,17 @@ button.small-btn {
 .map-container h2 { margin-bottom: 15px; text-align: center; }
 .map-content { display: flex; flex-wrap: wrap; gap: 20px; }
 .map {
-    flex: 3; min-width: 450px;
     height: 550px; 
     border: 1px solid var(--border-color); border-radius: 4px;
 }
-.map-info {
-    flex: 1; min-width: 300px;
+.map-info, .map-info-panel {
     display: flex; flex-direction: column;
-    height: 550px; 
-    max-height: 550px; 
-    overflow: hidden; 
+    overflow-y: auto;
 }
-.map-info p, .map-info .form-group {
+.map-info p, .map-info-panel p, .map-info .form-group, .map-info-panel .form-group {
     flex-shrink: 0; 
 }
-.map-info p { margin: 8px 0; }
+.map-info p, .map-info-panel p { margin: 8px 0; }
 .coordinates-list {
     margin-top: 15px;
     border: 1px solid var(--border-color); border-radius: 4px;
@@ -817,35 +813,84 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
     display: block;
 }
 
-/* ==================== Gerador de Stations ==================== */
-.station-generator-section {
+/* ==================== Gerador de Stations + Mapa (3 colunas) ==================== */
+.station-map-row {
+    display: flex;
+    gap: 15px;
+    margin-bottom: 20px;
     background-color: var(--card-bg-color);
     border-radius: 8px;
-    padding: 20px;
+    padding: 15px;
     box-shadow: 0 2px 10px var(--shadow-color);
-    margin-bottom: 20px;
+    align-items: stretch;
 }
-.station-generator-section h2 {
-    margin-bottom: 15px;
+.station-generator-panel {
+    flex: 0 0 280px;
+    max-width: 300px;
+    overflow-y: auto;
+    max-height: 620px;
+    padding-right: 10px;
+}
+.station-generator-panel h3 {
+    font-size: 1em;
+    margin-bottom: 12px;
+    color: var(--primary-color);
     text-align: center;
 }
-.station-controls-row {
+.station-generator-panel h4 {
+    font-size: 0.9em;
+    margin-bottom: 6px;
+    color: var(--primary-color);
+}
+.station-extra-params {
+    margin-bottom: 10px;
+}
+.station-extra-params .form-group {
+    margin-bottom: 6px;
+}
+.station-extra-params label {
+    font-size: 0.85em;
+}
+.station-extra-params input,
+.station-extra-params select {
+    font-size: 0.85em;
+    padding: 4px 6px;
+}
+.map-center-column {
+    flex: 1;
+    min-width: 350px;
     display: flex;
-    flex-wrap: wrap;
-    gap: 20px;
+    flex-direction: column;
+}
+.map-center-column h3 {
+    font-size: 1em;
+    margin-bottom: 8px;
+    text-align: center;
+    color: var(--primary-color);
 }
-.station-controls-panel {
+.map-center-column .map {
     flex: 1;
-    min-width: 280px;
-    max-width: 400px;
+    min-height: 500px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
 }
-.station-stats-panel {
-    flex: 2;
-    min-width: 300px;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 15px;
-    align-content: flex-start;
+.map-info-panel {
+    flex: 0 0 240px;
+    max-width: 280px;
+    overflow-y: auto;
+    max-height: 620px;
+    font-size: 0.9em;
+}
+.map-info-panel h3 {
+    font-size: 1em;
+    margin-bottom: 8px;
+    color: var(--primary-color);
+}
+.map-info-panel p {
+    margin-bottom: 5px;
+}
+.map-info-panel .form-group {
+    margin-bottom: 8px;
 }
 .info-box {
     background-color: var(--highlight-color);
@@ -1210,6 +1255,13 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
     display: flex;
     align-items: center;
     justify-content: center;
+    overflow: hidden;
+    position: relative;
+}
+.uv-plot-container .js-plotly-plot,
+.uv-plot-container .plot-container {
+    width: 100% !important;
+    max-width: 100%;
 }
 .uv-plot-container .plot-placeholder {
     font-style: italic;
@@ -1245,6 +1297,25 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
     .station-controls-panel {
         max-width: none;
     }
+    .station-map-row {
+        flex-direction: column;
+    }
+    .station-generator-panel {
+        flex: unset;
+        max-width: none;
+        max-height: none;
+    }
+    .map-info-panel {
+        flex: unset;
+        max-width: none;
+        max-height: none;
+    }
+    .map-center-column {
+        min-width: unset;
+    }
+    .map-center-column .map {
+        min-height: 350px;
+    }
     .ini-layout, .sky-model-layout, .uv-layout {
         flex-direction: column;
     }
diff --git a/index.html b/index.html
index d918409..99ce0ef 100644
--- a/index.html
+++ b/index.html
@@ -149,64 +149,87 @@ <h1>Gerador de Layouts de Antenas BINGO</h1>
         <!-- === ABA 1: LAYOUT PRINCIPAL === -->
         <div id="tab-layout" class="tab-content active" role="tabpanel">
 
-        <!-- Gerador de Stations -->
-        <section class="station-generator-section">
-            <h2><i class="fas fa-broadcast-tower"></i> Gerador de Posições de Stations</h2>
-            <div class="station-controls-row">
-                <div class="station-controls-panel">
-                    <div class="form-group">
-                        <label for="station-layout-type">Tipo de Layout:</label>
-                        <select id="station-layout-type">
-                            <option value="grid">Grid Regular</option>
-                            <option value="circular">Circular (Anel)</option>
-                            <option value="spiral">Espiral</option>
-                            <option value="y_shape">Forma em Y</option>
-                            <option value="cross">Cruz</option>
-                            <option value="random">Aleatório</option>
-                        </select>
-                    </div>
-                    <div class="form-group">
-                        <label for="station-count">Número de Stations:</label>
-                        <input type="number" id="station-count" value="7" min="2" max="100" step="1">
-                    </div>
-                    <div class="form-group">
-                        <label for="station-spacing">Espaçamento (m): <span id="station-spacing-value">300</span></label>
-                        <input type="range" id="station-spacing" min="0" max="1" step="0.001" value="0.565"
-                            title="Escala logarítmica: 15m — 3000m">
-                        <small class="slider-hint">Escala log: 15m — 3km (~30× a escala dos tiles)</small>
-                    </div>
-                    <div class="button-group">
-                        <button id="station-generate-btn" class="primary"><i class="fas fa-sync-alt"></i> Gerar Stations</button>
-                        <button id="station-random-btn" class="secondary"><i class="fas fa-random"></i> Randomizar</button>
-                    </div>
+        <!-- Stations + Mapa Interativo em layout lado-a-lado -->
+        <section class="station-map-row">
+            <!-- Coluna ESQUERDA: Gerador de Stations -->
+            <div class="station-generator-panel">
+                <h3><i class="fas fa-broadcast-tower"></i> Gerador de Posições de Stations</h3>
+                <div class="form-group">
+                    <label for="station-layout-type">Tipo de Layout:</label>
+                    <select id="station-layout-type">
+                        <option value="grid">Grid Regular</option>
+                        <option value="circular">Circular (Anel)</option>
+                        <option value="spiral">Espiral</option>
+                        <option value="y_shape">Forma em Y</option>
+                        <option value="cross">Cruz</option>
+                        <option value="random">Aleatório</option>
+                    </select>
                 </div>
-                <div class="station-stats-panel">
-                    <div id="station-stats" class="info-box">
-                        <h3>Estatísticas do Array</h3>
-                        <div class="stat-grid">
-                            <div class="stat-item"><span class="stat-label">Stations:</span> <span id="stat-station-count">0</span></div>
-                            <div class="stat-item"><span class="stat-label">Baselines:</span> <span id="stat-baseline-count">0</span></div>
-                        </div>
+                <div class="form-group">
+                    <label for="station-count">Número de Stations:</label>
+                    <input type="number" id="station-count" value="7" min="2" max="100" step="1">
+                </div>
+                <div class="form-group">
+                    <label for="station-spacing">Espaçamento (m): <span id="station-spacing-value">300</span></label>
+                    <input type="range" id="station-spacing" min="0" max="1" step="0.001" value="0.565"
+                        title="Escala logarítmica: 15m — 3000m">
+                    <small class="slider-hint">Escala log: 15m — 3km (~30× a escala dos tiles)</small>
+                </div>
+
+                <!-- Parâmetros extras por tipo de layout -->
+                <div id="station-extra-params" class="station-extra-params"></div>
+
+                <div class="button-group">
+                    <button id="station-generate-btn" class="primary"><i class="fas fa-sync-alt"></i> Gerar Stations</button>
+                    <button id="station-random-btn" class="secondary"><i class="fas fa-random"></i> Randomizar</button>
+                </div>
+
+                <div id="station-stats" class="info-box" style="margin-top: 12px;">
+                    <h4>Estatísticas do Array</h4>
+                    <div class="stat-grid">
+                        <div class="stat-item"><span class="stat-label">Stations:</span> <span id="stat-station-count">0</span></div>
+                        <div class="stat-item"><span class="stat-label">Baselines:</span> <span id="stat-baseline-count">0</span></div>
                     </div>
-                    <div id="angular-resolution-display" class="info-box highlight-box">
-                        <h3><i class="fas fa-crosshairs"></i> Resolução Angular</h3>
-                        <div class="resolution-values">
-                            <div>θ ≈ λ/D<sub>max</sub></div>
-                            <div id="resolution-arcmin" class="resolution-main">-- arcmin</div>
-                            <div id="resolution-arcsec" class="resolution-sub">-- arcsec</div>
-                        </div>
+                </div>
+                <div id="angular-resolution-display" class="info-box highlight-box" style="margin-top: 8px;">
+                    <h4><i class="fas fa-crosshairs"></i> Resolução Angular</h4>
+                    <div class="resolution-values">
+                        <div>θ ≈ λ/D<sub>max</sub></div>
+                        <div id="resolution-arcmin" class="resolution-main">-- arcmin</div>
+                        <div id="resolution-arcsec" class="resolution-sub">-- arcsec</div>
                     </div>
-                    <div id="baseline-info" class="info-box">
-                        <h3>Baselines</h3>
-                        <div class="stat-grid">
-                            <div class="stat-item"><span class="stat-label">Mín:</span> <span id="baseline-min">--</span></div>
-                            <div class="stat-item"><span class="stat-label">Máx:</span> <span id="baseline-max">--</span></div>
-                            <div class="stat-item baseline-short"><span class="stat-label">Curtas (&lt;50m):</span> <span id="baseline-short-count">0</span></div>
-                            <div class="stat-item baseline-long"><span class="stat-label">Longas (&gt;1km):</span> <span id="baseline-long-count">0</span></div>
-                        </div>
+                </div>
+                <div id="baseline-info" class="info-box" style="margin-top: 8px;">
+                    <h4>Baselines</h4>
+                    <div class="stat-grid">
+                        <div class="stat-item"><span class="stat-label">Mín:</span> <span id="baseline-min">--</span></div>
+                        <div class="stat-item"><span class="stat-label">Máx:</span> <span id="baseline-max">--</span></div>
+                        <div class="stat-item baseline-short"><span class="stat-label">Curtas (&lt;50m):</span> <span id="baseline-short-count">0</span></div>
+                        <div class="stat-item baseline-long"><span class="stat-label">Longas (&gt;1km):</span> <span id="baseline-long-count">0</span></div>
                     </div>
                 </div>
             </div>
+
+            <!-- Coluna CENTRAL: Mapa Interativo -->
+            <div class="map-center-column">
+                <h3>Mapa Interativo</h3>
+                <div id="map" class="map"></div>
+            </div>
+
+            <!-- Coluna DIREITA: Informações do Mapa -->
+            <div class="map-info-panel">
+                <h3>Informações</h3>
+                <p>Coordenadas selecionadas:</p>
+                <p><span id="selected-coords">Nenhuma</span></p>
+                <p>Distância ao BINGO: <span id="distance-to-bingo">0 km</span></p>
+                <p>Distância do cursor ao BINGO: <span id="dynamic-distance">0 km</span></p>
+                <p>Clique no mapa ou escolha um arranjo:</p>
+                <div class="form-group">
+                    <label for="arranjo-select">Arranjo:</label>
+                    <select id="arranjo-select"><option value="0">Selecione um arranjo</option></select>
+                </div>
+                <div id="coordinates-list" class="coordinates-list"></div>
+            </div>
         </section>
 
         <div class="generator-beam-row">
@@ -399,25 +422,6 @@ <h2>Padrão de Feixe Simulado</h2>
             </section>
         </div>
 
-        <section class="map-container">
-             <h2>Mapa Interativo</h2>
-             <div class="map-content">
-                 <div id="map" class="map"></div>
-                 <div class="map-info">
-                     <p>Coordenadas selecionadas:</p>
-                     <p><span id="selected-coords">Nenhuma</span></p>
-                     <p>Distância ao BINGO: <span id="distance-to-bingo">0 km</span></p>
-                     <p>Distância do cursor ao BINGO: <span id="dynamic-distance">0 km</span></p>
-                     <p>Clique no mapa ou escolha um arranjo:</p>
-                     <div class="form-group">
-                         <label for="arranjo-select">Arranjo:</label>
-                         <select id="arranjo-select"><option value="0">Selecione um arranjo</option></select>
-                     </div>
-                     <div id="coordinates-list" class="coordinates-list"></div>
-                 </div>
-             </div>
-         </section>
-
         <section class="export-container" aria-labelledby="export-heading">
             <h2 id="export-heading">Exportação (Estrutura OSKAR)</h2>
             <div class="export-fields">
diff --git a/js/stations.js b/js/stations.js
index 988901c..44a4dbd 100644
--- a/js/stations.js
+++ b/js/stations.js
@@ -72,6 +72,7 @@ class StationManager {
         this.statsContainerId = 'station-stats';
         this.angularResDisplayId = 'angular-resolution-display';
         this.baselineInfoId = 'baseline-info';
+        this.extraParamsContainerId = 'station-extra-params';
 
         // Referências aos elementos DOM
         this.layoutTypeSelect = null;
@@ -83,6 +84,7 @@ class StationManager {
         this.statsContainer = null;
         this.angularResDisplay = null;
         this.baselineInfo = null;
+        this.extraParamsContainer = null;
 
         // Estado interno
         this.stations = [];
@@ -103,6 +105,7 @@ class StationManager {
         this.statsContainer = document.getElementById(this.statsContainerId);
         this.angularResDisplay = document.getElementById(this.angularResDisplayId);
         this.baselineInfo = document.getElementById(this.baselineInfoId);
+        this.extraParamsContainer = document.getElementById(this.extraParamsContainerId);
 
         if (!this.generateBtn && !this.layoutTypeSelect) {
             console.warn("StationManager: Elementos DOM de estações não encontrados. Módulo em modo stand-by.");
@@ -116,6 +119,7 @@ class StationManager {
             this.randomBtn.addEventListener('click', () => {
                 if (this.layoutTypeSelect) {
                     this.layoutTypeSelect.value = 'random';
+                    this._updateExtraParams();
                 }
                 this.generateStations();
             });
@@ -123,8 +127,12 @@ class StationManager {
         if (this.spacingRange) {
             this.spacingRange.addEventListener('input', () => this._updateSpacingDisplay());
         }
+        if (this.layoutTypeSelect) {
+            this.layoutTypeSelect.addEventListener('change', () => this._updateExtraParams());
+        }
 
         this._updateSpacingDisplay();
+        this._updateExtraParams();
         console.log("StationManager: Módulo de estações inicializado.");
     }
 
@@ -154,6 +162,81 @@ class StationManager {
         }
     }
 
+    // ===========================
+    // Parâmetros Extras por Tipo
+    // ===========================
+
+    /**
+     * Lê um valor numérico de um parâmetro extra.
+     * @param {string} id ID do input
+     * @param {number} fallback Valor padrão
+     * @returns {number}
+     */
+    _getExtraParam(id, fallback) {
+        const el = document.getElementById(id);
+        if (!el) return fallback;
+        const v = parseFloat(el.value);
+        return isNaN(v) ? fallback : v;
+    }
+
+    /**
+     * Atualiza os parâmetros extras exibidos conforme o tipo de layout selecionado.
+     */
+    _updateExtraParams() {
+        if (!this.extraParamsContainer) return;
+        const layout = this.layoutTypeSelect ? this.layoutTypeSelect.value : 'grid';
+
+        const paramDefs = {
+            grid: [
+                { id: 'sp-grid-cols', label: 'Colunas', type: 'number', value: 0, min: 0, max: 50, step: 1, hint: '0 = automático (√N)' },
+                { id: 'sp-grid-sx', label: 'Fator Espaç. X', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
+                { id: 'sp-grid-sy', label: 'Fator Espaç. Y', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
+                { id: 'sp-grid-jitter', label: 'Jitter aleatório (m)', type: 'number', value: 0, min: 0, max: 100, step: 1 }
+            ],
+            circular: [
+                { id: 'sp-circ-rings', label: 'Número de anéis', type: 'number', value: 1, min: 1, max: 10, step: 1 },
+                { id: 'sp-circ-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 },
+                { id: 'sp-circ-inner', label: 'Raio interno (fração)', type: 'number', value: 0.5, min: 0.1, max: 1.0, step: 0.05 }
+            ],
+            spiral: [
+                { id: 'sp-spiral-turns', label: 'Número de voltas', type: 'number', value: 3, min: 1, max: 20, step: 0.5 },
+                { id: 'sp-spiral-growth', label: 'Fator de crescimento', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
+                { id: 'sp-spiral-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 }
+            ],
+            y_shape: [
+                { id: 'sp-y-arms', label: 'Número de braços', type: 'number', value: 3, min: 2, max: 8, step: 1 },
+                { id: 'sp-y-angle', label: 'Ângulo inicial (°)', type: 'number', value: 90, min: 0, max: 360, step: 5 },
+                { id: 'sp-y-curve', label: 'Curvatura dos braços', type: 'number', value: 0, min: -0.5, max: 0.5, step: 0.05 },
+                { id: 'sp-y-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '0' }
+            ],
+            cross: [
+                { id: 'sp-cross-angle', label: 'Ângulo de rotação (°)', type: 'number', value: 0, min: 0, max: 90, step: 5 },
+                { id: 'sp-cross-spacing-ratio', label: 'Proporção espaç. vert/horiz', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
+                { id: 'sp-cross-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '0' }
+            ],
+            random: [
+                { id: 'sp-rand-shape', label: 'Forma da área', type: 'select', options: [{ v: 'circle', t: 'Círculo' }, { v: 'square', t: 'Quadrado' }], value: 'circle' },
+                { id: 'sp-rand-mindist', label: 'Distância mín. entre stations (m)', type: 'number', value: 0, min: 0, max: 500, step: 5 },
+                { id: 'sp-rand-seed', label: 'Semente (0 = aleatório)', type: 'number', value: 0, min: 0, max: 99999, step: 1 }
+            ]
+        };
+
+        const defs = paramDefs[layout] || [];
+        let html = '';
+        for (const p of defs) {
+            if (p.type === 'select') {
+                const opts = p.options.map(o => `<option value="${o.v}"${o.v === p.value ? ' selected' : ''}>${o.t}</option>`).join('');
+                html += `<div class="form-group"><label for="${p.id}">${p.label}:</label><select id="${p.id}">${opts}</select></div>`;
+            } else {
+                html += `<div class="form-group"><label for="${p.id}">${p.label}:</label>` +
+                    `<input type="number" id="${p.id}" value="${p.value}" min="${p.min}" max="${p.max}" step="${p.step}">` +
+                    (p.hint ? `<small class="slider-hint">${p.hint}</small>` : '') +
+                    `</div>`;
+            }
+        }
+        this.extraParamsContainer.innerHTML = html;
+    }
+
     /**
      * Gera posições de estações com base nas configurações atuais da UI.
      */
@@ -195,6 +278,7 @@ class StationManager {
         this.calculateBaselines();
         this.calculateAngularResolution();
         this.updateStats();
+        this._pushStationsToMap();
         this._dispatchEvent();
 
         console.log(`StationManager: ${this.stations.length} estações geradas (layout: ${layoutType}, espaçamento: ${spacing.toFixed(1)}m).`);
@@ -218,96 +302,195 @@ class StationManager {
         }));
     }
 
+    // ===========================
+    // Conversão para Mapa e Integração
+    // ===========================
+
+    /**
+     * Converte posição local (x: East, y: North) em metros relativas ao BINGO Central
+     * para coordenadas WGS84 (lat, lon).
+     * @param {number} xEast Deslocamento East em metros
+     * @param {number} yNorth Deslocamento North em metros
+     * @returns {{lat: number, lon: number, alt: number}}
+     */
+    _localToWgs84(xEast, yNorth) {
+        const refLat = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_LATITUDE : -7.04067;
+        const refLon = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_LONGITUDE : -38.26884;
+        const refAlt = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_ALTITUDE : 396.4;
+
+        const latRad = refLat * Math.PI / 180;
+        // metros por grau de latitude e longitude
+        const mPerDegLat = 111132.92 - 559.82 * Math.cos(2 * latRad) + 1.175 * Math.cos(4 * latRad);
+        const mPerDegLon = 111412.84 * Math.cos(latRad) - 93.5 * Math.cos(3 * latRad);
+
+        return {
+            lat: refLat + (yNorth / mPerDegLat),
+            lon: refLon + (xEast / mPerDegLon),
+            alt: refAlt
+        };
+    }
+
+    /**
+     * Converte todas as estações para WGS84 e retorna.
+     * @returns {Array<{lat: number, lon: number, alt: number}>}
+     */
+    getStationsAsWGS84() {
+        return this.stations.map(s => this._localToWgs84(s.x, s.y));
+    }
+
+    /**
+     * Empurra as estações geradas para o mapa interativo (se disponível)
+     * e atualiza os campos de exportação WGS84, ECEF e ENU.
+     */
+    _pushStationsToMap() {
+        const wgs84Stations = this.getStationsAsWGS84();
+
+        // Atualiza o mapa interativo, se presente
+        if (window.interactiveMap) {
+            const map = window.interactiveMap;
+            // Limpa marcadores antigos
+            while (map.stationMarkers && map.stationMarkers.length > 0) {
+                map.removeMarker(0);
+            }
+            // Adiciona novos marcadores
+            wgs84Stations.forEach((st, i) => {
+                map.addMarker(st.lat, st.lon, st.alt, `Station ${i + 1}`);
+            });
+
+            // Ajusta visualização para mostrar todas as estações
+            if (map.stationMarkers && map.stationMarkers.length > 0 && map.map) {
+                const group = L.featureGroup(map.stationMarkers);
+                map.map.fitBounds(group.getBounds().pad(0.15));
+            }
+        }
+
+        // Atualiza os campos de exportação diretamente
+        const stationCoords = wgs84Stations.map((st, i) => ({
+            lat: st.lat,
+            lon: st.lon,
+            alt: st.alt,
+            name: `Station ${i + 1}`
+        }));
+
+        if (window.oskarExporter) {
+            window.oskarExporter.updateAllExportFields(null, stationCoords);
+        } else if (typeof window.updateExportFields === 'function') {
+            window.updateExportFields(null, stationCoords);
+        }
+    }
+
     // ===========================
     // Métodos de Geração de Layout
     // ===========================
 
     /**
      * Gera estações em um grid regular.
-     * @param {number} count Número de estações.
-     * @param {number} spacing Espaçamento em metros.
-     * @returns {Array<{x: number, y: number}>} Posições das estações.
      */
     generateGridStations(count, spacing) {
-        const cols = Math.ceil(Math.sqrt(count));
+        const forcedCols = this._getExtraParam('sp-grid-cols', 0);
+        const sx = this._getExtraParam('sp-grid-sx', 1.0);
+        const sy = this._getExtraParam('sp-grid-sy', 1.0);
+        const jitter = this._getExtraParam('sp-grid-jitter', 0);
+
+        const cols = (forcedCols > 0) ? forcedCols : Math.ceil(Math.sqrt(count));
         const rows = Math.ceil(count / cols);
         const positions = [];
         for (let r = 0; r < rows && positions.length < count; r++) {
             for (let c = 0; c < cols && positions.length < count; c++) {
-                positions.push({
-                    x: c * spacing,
-                    y: r * spacing
-                });
+                let x = c * spacing * sx;
+                let y = r * spacing * sy;
+                if (jitter > 0) {
+                    x += (Math.random() - 0.5) * 2 * jitter;
+                    y += (Math.random() - 0.5) * 2 * jitter;
+                }
+                positions.push({ x, y });
             }
         }
         return positions;
     }
 
     /**
-     * Gera estações em um anel circular.
-     * @param {number} count Número de estações.
-     * @param {number} spacing Espaçamento em metros (usado como raio).
-     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     * Gera estações em anéis circulares.
      */
     generateCircularStations(count, spacing) {
+        const rings = this._getExtraParam('sp-circ-rings', 1);
+        const offsetDeg = this._getExtraParam('sp-circ-offset', 0);
+        const innerFrac = this._getExtraParam('sp-circ-inner', 0.5);
+
         const positions = [];
-        const radius = spacing;
-        for (let i = 0; i < count; i++) {
-            const angle = (2 * Math.PI * i) / count;
-            positions.push({
-                x: radius * Math.cos(angle),
-                y: radius * Math.sin(angle)
-            });
+        const offsetRad = offsetDeg * Math.PI / 180;
+
+        if (rings === 1) {
+            const radius = spacing;
+            for (let i = 0; i < count; i++) {
+                const angle = (2 * Math.PI * i) / count + offsetRad;
+                positions.push({ x: radius * Math.cos(angle), y: radius * Math.sin(angle) });
+            }
+        } else {
+            const perRing = Math.max(1, Math.floor(count / rings));
+            let remaining = count;
+            for (let ring = 0; ring < rings && remaining > 0; ring++) {
+                const frac = rings === 1 ? 1 : innerFrac + (1 - innerFrac) * (ring / (rings - 1));
+                const radius = spacing * frac;
+                const n = (ring === rings - 1) ? remaining : Math.min(perRing, remaining);
+                const ringOffset = offsetRad + (ring % 2 === 1 ? Math.PI / n : 0);
+                for (let i = 0; i < n; i++) {
+                    const angle = (2 * Math.PI * i) / n + ringOffset;
+                    positions.push({ x: radius * Math.cos(angle), y: radius * Math.sin(angle) });
+                }
+                remaining -= n;
+            }
         }
         return positions;
     }
 
     /**
      * Gera estações em uma espiral.
-     * @param {number} count Número de estações.
-     * @param {number} spacing Espaçamento em metros (controla o passo radial).
-     * @returns {Array<{x: number, y: number}>} Posições das estações.
      */
     generateSpiralStations(count, spacing) {
+        const turns = this._getExtraParam('sp-spiral-turns', 3);
+        const growth = this._getExtraParam('sp-spiral-growth', 1.0);
+        const offsetDeg = this._getExtraParam('sp-spiral-offset', 0);
+        const offsetRad = offsetDeg * Math.PI / 180;
+
         const positions = [];
-        const goldenAngle = Math.PI * (3 - Math.sqrt(5));
         for (let i = 0; i < count; i++) {
-            const r = spacing * Math.sqrt(i + 1) / Math.sqrt(count);
-            const theta = i * goldenAngle;
-            positions.push({
-                x: r * Math.cos(theta),
-                y: r * Math.sin(theta)
-            });
+            const t = (i + 1) / count; // 0..1
+            const r = spacing * Math.pow(t, growth);
+            const theta = 2 * Math.PI * turns * t + offsetRad;
+            positions.push({ x: r * Math.cos(theta), y: r * Math.sin(theta) });
         }
         return positions;
     }
 
     /**
-     * Gera estações em um layout em forma de Y (comum em radioastronomia).
-     * @param {number} count Número de estações.
-     * @param {number} spacing Espaçamento em metros.
-     * @returns {Array<{x: number, y: number}>} Posições das estações.
+     * Gera estações em um layout com braços radiais (Y, estrela, etc.).
      */
     generateYShapeStations(count, spacing) {
+        const arms = Math.max(2, this._getExtraParam('sp-y-arms', 3));
+        const angleDeg = this._getExtraParam('sp-y-angle', 90);
+        const curve = this._getExtraParam('sp-y-curve', 0);
+        const addCore = this._getExtraParam('sp-y-core', 0) === 1;
+
         const positions = [];
-        const arms = 3;
-        const perArm = Math.floor(count / arms);
-        const remainder = count - perArm * arms;
-        const armAngles = [
-            Math.PI / 2,                    // braço superior (90°)
-            Math.PI / 2 + (2 * Math.PI / 3), // braço inferior esquerdo (210°)
-            Math.PI / 2 + (4 * Math.PI / 3)  // braço inferior direito (330°)
-        ];
+        const baseAngle = angleDeg * Math.PI / 180;
+        let stationsLeft = addCore ? count - 1 : count;
+        if (addCore && stationsLeft >= 0) {
+            positions.push({ x: 0, y: 0 });
+        }
+        if (stationsLeft < 1) stationsLeft = count;
+
+        const perArm = Math.floor(stationsLeft / arms);
+        const remainder = stationsLeft - perArm * arms;
 
         for (let a = 0; a < arms; a++) {
             const stationsInArm = perArm + (a < remainder ? 1 : 0);
-            const angle = armAngles[a];
+            const armAngle = baseAngle + (2 * Math.PI * a) / arms;
             for (let i = 0; i < stationsInArm; i++) {
                 const dist = spacing * (i + 1);
-                positions.push({
-                    x: dist * Math.cos(angle),
-                    y: dist * Math.sin(angle)
-                });
+                const curveAngle = curve * (i + 1) * (i + 1) / stationsInArm;
+                const angle = armAngle + curveAngle;
+                positions.push({ x: dist * Math.cos(angle), y: dist * Math.sin(angle) });
             }
         }
         return positions;
@@ -315,25 +498,32 @@ class StationManager {
 
     /**
      * Gera estações em um layout em forma de cruz.
-     * @param {number} count Número de estações.
-     * @param {number} spacing Espaçamento em metros.
-     * @returns {Array<{x: number, y: number}>} Posições das estações.
      */
     generateCrossStations(count, spacing) {
+        const rotDeg = this._getExtraParam('sp-cross-angle', 0);
+        const spacingRatio = this._getExtraParam('sp-cross-spacing-ratio', 1.0);
+        const addCore = this._getExtraParam('sp-cross-core', 0) === 1;
+
+        const rotRad = rotDeg * Math.PI / 180;
         const positions = [];
+        let stationsLeft = addCore ? count - 1 : count;
+        if (addCore && stationsLeft >= 0) {
+            positions.push({ x: 0, y: 0 });
+        }
+        if (stationsLeft < 1) stationsLeft = count;
+
         const arms = 4;
-        const perArm = Math.floor(count / arms);
-        const remainder = count - perArm * arms;
+        const perArm = Math.floor(stationsLeft / arms);
+        const remainder = stationsLeft - perArm * arms;
         const armAngles = [0, Math.PI / 2, Math.PI, 3 * Math.PI / 2];
 
         for (let a = 0; a < arms; a++) {
             const stationsInArm = perArm + (a < remainder ? 1 : 0);
+            const armAngle = armAngles[a] + rotRad;
+            const spc = (a === 1 || a === 3) ? spacing * spacingRatio : spacing;
             for (let i = 0; i < stationsInArm; i++) {
-                const dist = spacing * (i + 1);
-                positions.push({
-                    x: dist * Math.cos(armAngles[a]),
-                    y: dist * Math.sin(armAngles[a])
-                });
+                const dist = spc * (i + 1);
+                positions.push({ x: dist * Math.cos(armAngle), y: dist * Math.sin(armAngle) });
             }
         }
         return positions;
@@ -341,18 +531,51 @@ class StationManager {
 
     /**
      * Gera estações com distribuição aleatória.
-     * @param {number} count Número de estações.
-     * @param {number} spacing Espaçamento em metros (define o raio da área).
-     * @returns {Array<{x: number, y: number}>} Posições das estações.
      */
     generateRandomStations(count, spacing) {
-        const positions = [];
+        const shape = (() => { const el = document.getElementById('sp-rand-shape'); return el ? el.value : 'circle'; })();
+        const minDist = this._getExtraParam('sp-rand-mindist', 0);
+        const seed = this._getExtraParam('sp-rand-seed', 0);
+
+        // Pseudo-random com semente
+        let rng;
+        if (seed > 0) {
+            let s = seed;
+            rng = () => { s = (s * 16807 + 0) % 2147483647; return (s - 1) / 2147483646; };
+        } else {
+            rng = Math.random;
+        }
+
         const area = spacing * Math.sqrt(count);
-        for (let i = 0; i < count; i++) {
-            positions.push({
-                x: (Math.random() - 0.5) * 2 * area,
-                y: (Math.random() - 0.5) * 2 * area
-            });
+        const positions = [];
+        const maxAttempts = count * 200;
+        let attempts = 0;
+
+        while (positions.length < count && attempts < maxAttempts) {
+            attempts++;
+            let x, y;
+            if (shape === 'circle') {
+                const r = area * Math.sqrt(rng());
+                const theta = 2 * Math.PI * rng();
+                x = r * Math.cos(theta);
+                y = r * Math.sin(theta);
+            } else {
+                x = (rng() - 0.5) * 2 * area;
+                y = (rng() - 0.5) * 2 * area;
+            }
+
+            if (minDist > 0) {
+                let tooClose = false;
+                for (const p of positions) {
+                    const dx = p.x - x, dy = p.y - y;
+                    if (Math.sqrt(dx * dx + dy * dy) < minDist) {
+                        tooClose = true;
+                        break;
+                    }
+                }
+                if (tooClose) continue;
+            }
+            positions.push({ x, y });
         }
         return positions;
     }
diff --git a/js/uv_coverage.js b/js/uv_coverage.js
index 85de8b4..61973ef 100644
--- a/js/uv_coverage.js
+++ b/js/uv_coverage.js
@@ -247,6 +247,17 @@ class UVCoverageSimulator {
             ? (lambda / maxBaseline) * BingoConstants.RAD_TO_DEG * 60
             : 0;
 
+        // Calcula limites dos eixos a partir dos extremos dos dados × 1.1
+        let uMax = 0, vMax = 0;
+        for (let i = 0; i < uPoints.length; i++) {
+            const au = Math.abs(uPoints[i]);
+            const av = Math.abs(vPoints[i]);
+            if (au > uMax) uMax = au;
+            if (av > vMax) vMax = av;
+        }
+        const uLimit = uMax * 1.1 || 1;
+        const vLimit = vMax * 1.1 || 1;
+
         const trace = {
             x: uPoints,
             y: vPoints,
@@ -273,16 +284,19 @@ class UVCoverageSimulator {
             title: 'Cobertura UV',
             xaxis: {
                 title: 'u (comprimentos de onda)',
-                scaleanchor: 'y',
-                scaleratio: 1,
+                range: [-uLimit, uLimit],
                 zeroline: true,
-                zerolinecolor: '#888'
+                zerolinecolor: '#888',
+                constrain: 'range'
             },
             yaxis: {
                 title: 'v (comprimentos de onda)',
+                range: [-vLimit, vLimit],
                 zeroline: true,
-                zerolinecolor: '#888'
+                zerolinecolor: '#888',
+                constrain: 'range'
             },
+            dragmode: 'zoom',
             hovermode: 'closest',
             plot_bgcolor: '#1a1a2e',
             paper_bgcolor: '#16213e',
@@ -298,7 +312,8 @@ class UVCoverageSimulator {
                 bgcolor: 'rgba(0,0,0,0.5)',
                 borderpad: 4
             }],
-            margin: { t: 50, b: 60, l: 60, r: 20 }
+            margin: { t: 50, b: 60, l: 60, r: 20 },
+            autosize: true
         };
 
         const config = {

From 8e74d0f62b24904696e0cf0d24cc9411856e0ce6 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 22:22:18 +0000
Subject: [PATCH 12/22] Address code review: fix edge cases, add code comments,
 normalize CSS sizing

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css | 13 +++++++++++--
 js/stations.js | 17 ++++++++++-------
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index 938f9ac..28a3674 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -826,7 +826,7 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
 }
 .station-generator-panel {
     flex: 0 0 280px;
-    max-width: 300px;
+    max-width: 280px;
     overflow-y: auto;
     max-height: 620px;
     padding-right: 10px;
@@ -1376,12 +1376,21 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
     .generator-beam-row { flex-direction: column; }
     .layout-generator, .beam-pattern-container { flex-basis: auto; min-width: unset; width: 100%; }
     .map-content { flex-direction: column; }
-    .map, .map-info {
+    .map, .map-info, .map-info-panel {
         flex: unset; min-width: unset; width: 100%;
         height: auto; 
         max-height: none; 
     }
     .map { height: 450px; }
+    .station-map-row {
+        flex-wrap: wrap;
+    }
+    .station-generator-panel {
+        flex: 0 0 260px;
+    }
+    .map-info-panel {
+        flex: 0 0 220px;
+    }
     .coordinates-list {
         max-height: 250px; 
         height: 250px; 
diff --git a/js/stations.js b/js/stations.js
index 44a4dbd..3bb638c 100644
--- a/js/stations.js
+++ b/js/stations.js
@@ -309,6 +309,7 @@ class StationManager {
     /**
      * Converte posição local (x: East, y: North) em metros relativas ao BINGO Central
      * para coordenadas WGS84 (lat, lon).
+     * Usa aproximação WGS84 para metros por grau no ponto de referência.
      * @param {number} xEast Deslocamento East em metros
      * @param {number} yNorth Deslocamento North em metros
      * @returns {{lat: number, lon: number, alt: number}}
@@ -319,7 +320,7 @@ class StationManager {
         const refAlt = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_ALTITUDE : 396.4;
 
         const latRad = refLat * Math.PI / 180;
-        // metros por grau de latitude e longitude
+        // WGS84 ellipsoid series expansion for meters per degree (IAG 1980)
         const mPerDegLat = 111132.92 - 559.82 * Math.cos(2 * latRad) + 1.175 * Math.cos(4 * latRad);
         const mPerDegLon = 111412.84 * Math.cos(latRad) - 93.5 * Math.cos(3 * latRad);
 
@@ -475,10 +476,10 @@ class StationManager {
         const positions = [];
         const baseAngle = angleDeg * Math.PI / 180;
         let stationsLeft = addCore ? count - 1 : count;
-        if (addCore && stationsLeft >= 0) {
+        if (addCore) {
             positions.push({ x: 0, y: 0 });
         }
-        if (stationsLeft < 1) stationsLeft = count;
+        if (stationsLeft < 1) return positions;
 
         const perArm = Math.floor(stationsLeft / arms);
         const remainder = stationsLeft - perArm * arms;
@@ -507,10 +508,10 @@ class StationManager {
         const rotRad = rotDeg * Math.PI / 180;
         const positions = [];
         let stationsLeft = addCore ? count - 1 : count;
-        if (addCore && stationsLeft >= 0) {
+        if (addCore) {
             positions.push({ x: 0, y: 0 });
         }
-        if (stationsLeft < 1) stationsLeft = count;
+        if (stationsLeft < 1) return positions;
 
         const arms = 4;
         const perArm = Math.floor(stationsLeft / arms);
@@ -537,11 +538,13 @@ class StationManager {
         const minDist = this._getExtraParam('sp-rand-mindist', 0);
         const seed = this._getExtraParam('sp-rand-seed', 0);
 
-        // Pseudo-random com semente
+        // Pseudo-random with seed using Park-Miller MINSTD algorithm
         let rng;
         if (seed > 0) {
             let s = seed;
-            rng = () => { s = (s * 16807 + 0) % 2147483647; return (s - 1) / 2147483646; };
+            const PRNG_MULTIPLIER = 16807;      // 7^5
+            const PRNG_MODULUS = 2147483647;     // 2^31 - 1
+            rng = () => { s = (s * PRNG_MULTIPLIER + 0) % PRNG_MODULUS; return (s - 1) / (PRNG_MODULUS - 1); };
         } else {
             rng = Math.random;
         }

From 47e503aa3760543d04e4f396f209bf4defa896ed Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 23:09:04 +0000
Subject: [PATCH 13/22] Add map distance toggle, INI [General] section, sky-INI
 integration, file browser buttons, and complete OSKAR parameters

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css      |  26 ++
 index.html          |   3 +
 js/ini_generator.js | 849 ++++++++++++++++++++++++++++++++++++--------
 js/map.js           |   9 +-
 4 files changed, 736 insertions(+), 151 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index 28a3674..031700d 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -1090,6 +1090,32 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
     border-color: #e74c3c;
     box-shadow: 0 0 0 2px rgba(231, 76, 60, 0.2);
 }
+.ini-file-input-wrapper {
+    flex: 2;
+    min-width: 200px;
+    display: flex;
+    gap: 4px;
+    align-items: center;
+}
+.ini-file-input-wrapper .ini-param-input {
+    flex: 1;
+    min-width: 0;
+}
+.ini-browse-btn {
+    flex-shrink: 0;
+    padding: 6px 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background-color: var(--highlight-color);
+    color: var(--text-color);
+    cursor: pointer;
+    font-size: 0.85em;
+    transition: background-color 0.15s, color 0.15s;
+}
+.ini-browse-btn:hover {
+    background-color: var(--primary-color);
+    color: #fff;
+}
 .ini-collapsible-toggle {
     cursor: pointer;
     padding: 8px;
diff --git a/index.html b/index.html
index 99ce0ef..2d21e94 100644
--- a/index.html
+++ b/index.html
@@ -477,6 +477,9 @@ <h2><i class="fas fa-cogs"></i> Gerador de Arquivo de Observação (.ini)</h2>
                             <button id="ini-fill-from-layout-btn" class="primary small-btn" title="Preenche os campos do telescópio com os dados do layout e mapa atuais">
                                 <i class="fas fa-magic"></i> Preencher a partir do Layout Atual
                             </button>
+                            <button id="ini-use-sky-model-btn" class="secondary small-btn" title="Usa o modelo de céu gerado na aba Sky Model como entrada. Ambos serão baixados juntos.">
+                                <i class="fas fa-star"></i> Usar Modelo de Céu Gerado
+                            </button>
                         </div>
                         <div id="ini-params-container" class="ini-params-container">
                             <!-- Parâmetros renderizados dinamicamente por ini_generator.js -->
diff --git a/js/ini_generator.js b/js/ini_generator.js
index 7843aa9..831b0f0 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -28,40 +28,79 @@ const OSKAR_INI_PARAMS = Object.freeze([
     // =========================================================================
     // [simulator]
     // =========================================================================
+    {
+        key: 'double_precision',
+        section: 'simulator',
+        label: 'Precisão dupla',
+        tooltip: 'Ativa cálculos em precisão dupla (64 bits). Mais exato, porém mais lento na GPU.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim (mais preciso)' },
+            { value: 'false', label: 'Não (mais rápido)' }
+        ]
+    },
+    {
+        key: 'use_gpus',
+        section: 'simulator',
+        label: 'Usar GPUs',
+        tooltip: 'Se habilitado, usa dispositivos GPU disponíveis para a simulação.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'cuda_device_ids',
+        section: 'simulator',
+        label: 'IDs de dispositivos CUDA',
+        tooltip: 'Lista separada por vírgulas de IDs de GPUs, ou "all" para usar todos os dispositivos.',
+        type: 'text',
+        defaultValue: 'all',
+        category: 'advanced'
+    },
+    {
+        key: 'num_devices',
+        section: 'simulator',
+        label: 'Número de dispositivos',
+        tooltip: 'Número de dispositivos de computação (CPU cores ou GPUs). "auto" detecta automaticamente.',
+        type: 'text',
+        defaultValue: 'auto',
+        category: 'advanced'
+    },
     {
         key: 'max_sources_per_chunk',
         section: 'simulator',
         label: 'Fontes por bloco',
-        tooltip: 'Número máximo de fontes de céu processadas simultaneamente por bloco de memória. ' +
-                 'Valores maiores usam mais memória da GPU, mas podem ser mais rápidos. ' +
-                 'Reduza se ocorrerem erros de falta de memória na GPU.',
+        tooltip: 'Máximo de fontes processadas por bloco. Reduza se a GPU ficar sem memória.',
         type: 'number',
         defaultValue: 16384,
         category: 'advanced'
     },
     {
-        key: 'double_precision',
+        key: 'keep_log_file',
         section: 'simulator',
-        label: 'Precisão dupla',
-        tooltip: 'Ativa cálculos em precisão dupla (64 bits) em vez de precisão simples (32 bits). ' +
-                 'Precisão dupla é mais exata, porém significativamente mais lenta na GPU. ' +
-                 'Use "true" para simulações de alta fidelidade.',
+        label: 'Manter log',
+        tooltip: 'Salva um arquivo de log no disco com informações da simulação.',
         type: 'select',
         defaultValue: 'false',
         category: 'advanced',
         options: [
-            { value: 'true', label: 'Sim (mais preciso, mais lento)' },
-            { value: 'false', label: 'Não (mais rápido, precisão simples)' }
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
         ]
     },
     {
-        key: 'keep_log_file',
+        key: 'write_status_to_log_file',
         section: 'simulator',
-        label: 'Manter log',
-        tooltip: 'Quando habilitado, o OSKAR salva um arquivo de log detalhado com informações ' +
-                 'sobre o progresso e eventuais erros da simulação. Útil para depuração.',
+        label: 'Status no log',
+        tooltip: 'Se habilitado, escreve mensagens de progresso no arquivo de log.',
         type: 'select',
-        defaultValue: 'true',
+        defaultValue: 'false',
         category: 'advanced',
         options: [
             { value: 'true', label: 'Sim' },
@@ -76,84 +115,290 @@ const OSKAR_INI_PARAMS = Object.freeze([
         key: 'oskar_sky_model/file',
         section: 'sky',
         label: 'Arquivo do modelo de céu',
-        tooltip: 'Caminho para o arquivo do modelo de céu (.osm ou .txt) contendo as fontes ' +
-                 'a serem simuladas. Cada linha define uma fonte com posição (RA, Dec) e fluxo. ' +
-                 'Este é um parâmetro obrigatório para executar a simulação.',
+        tooltip: 'Caminho para o arquivo do modelo de céu (.osm ou .txt). ' +
+                 'Cada linha define uma fonte com posição (RA, Dec), fluxo e outros parâmetros.',
         type: 'text',
         defaultValue: '',
         category: 'essential',
-        required: true
+        required: true,
+        isFilePath: true,
+        fileAccept: '.osm,.txt,.sky'
+    },
+    {
+        key: 'fits_image/file',
+        section: 'sky',
+        label: 'Arquivo FITS (imagem)',
+        tooltip: 'Caminho para arquivo(s) FITS para usar como modelo de céu.',
+        type: 'text',
+        defaultValue: '',
+        category: 'advanced',
+        isFilePath: true,
+        fileAccept: '.fits,.fit'
+    },
+    {
+        key: 'fits_image/default_map_units',
+        section: 'sky',
+        label: 'Unidade padrão do mapa FITS',
+        tooltip: 'Unidade física dos pixels do mapa FITS, se não especificada no arquivo.',
+        type: 'select',
+        defaultValue: 'Jy/beam',
+        category: 'advanced',
+        options: [
+            { value: 'Jy/beam', label: 'Jy/beam' },
+            { value: 'Jy/pixel', label: 'Jy/pixel' },
+            { value: 'K', label: 'K (Kelvin)' }
+        ]
+    },
+    {
+        key: 'fits_image/spectral_index',
+        section: 'sky',
+        label: 'Índice espectral (FITS)',
+        tooltip: 'Índice espectral atribuído a cada pixel do mapa FITS.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'fits_image/min_peak_fraction',
+        section: 'sky',
+        label: 'Fração mín. do pico (FITS)',
+        tooltip: 'Valor mínimo de pixel como fração do pico. 0 ou negativo desativa o filtro.',
+        type: 'number',
+        defaultValue: 0.02,
+        category: 'advanced'
+    },
+    {
+        key: 'healpix_fits/file',
+        section: 'sky',
+        label: 'Arquivo HEALPix FITS',
+        tooltip: 'Caminho para arquivo(s) HEALPix FITS (esquema RING apenas).',
+        type: 'text',
+        defaultValue: '',
+        category: 'advanced',
+        isFilePath: true,
+        fileAccept: '.fits,.fit'
+    },
+    {
+        key: 'healpix_fits/default_map_units',
+        section: 'sky',
+        label: 'Unidade padrão do HEALPix',
+        tooltip: 'Unidade dos pixels no mapa HEALPix, se não especificada no arquivo.',
+        type: 'select',
+        defaultValue: 'K',
+        category: 'advanced',
+        options: [
+            { value: 'K', label: 'K (Kelvin)' },
+            { value: 'Jy/pixel', label: 'Jy/pixel' },
+            { value: 'Jy/beam', label: 'Jy/beam' }
+        ]
+    },
+    {
+        key: 'healpix_fits/spectral_index',
+        section: 'sky',
+        label: 'Índice espectral (HEALPix)',
+        tooltip: 'Índice espectral de cada pixel HEALPix.',
+        type: 'number',
+        defaultValue: -0.7,
+        category: 'advanced'
+    },
+    {
+        key: 'healpix_fits/coord_sys',
+        section: 'sky',
+        label: 'Sistema de coordenadas (HEALPix)',
+        tooltip: 'Sistema de coordenadas esféricas para o HEALPix.',
+        type: 'select',
+        defaultValue: 'G',
+        category: 'advanced',
+        options: [
+            { value: 'G', label: 'Galáctico (G)' },
+            { value: 'C', label: 'Celeste/Equatorial (C)' }
+        ]
+    },
+    {
+        key: 'healpix_fits/freq_hz',
+        section: 'sky',
+        label: 'Frequência de referência HEALPix (Hz)',
+        tooltip: 'Frequência para conversão de temperatura de brilho para Jy/pixel.',
+        type: 'number',
+        defaultValue: 408e6,
+        category: 'advanced'
+    },
+    {
+        key: 'spectral_index/override',
+        section: 'sky',
+        label: 'Sobrescrever índice espectral',
+        tooltip: 'Se habilitado, sobrescreve todos os índices espectrais das fontes.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'spectral_index/ref_frequency_hz',
+        section: 'sky',
+        label: 'Freq. de referência do índice (Hz)',
+        tooltip: 'Frequência de referência para todos os índices espectrais no modelo final.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'spectral_index/mean',
+        section: 'sky',
+        label: 'Média do índice espectral',
+        tooltip: 'Média dos índices espectrais no modelo de céu final.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'spectral_index/std_dev',
+        section: 'sky',
+        label: 'Desvio padrão do índice espectral',
+        tooltip: 'Desvio padrão dos índices espectrais no modelo de céu final.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'common_flux_filter/flux_min',
+        section: 'sky',
+        label: 'Fluxo mínimo (Jy)',
+        tooltip: 'Fluxo mínimo permitido pelo filtro, em Jy. "min" desativa.',
+        type: 'text',
+        defaultValue: 'min',
+        category: 'advanced'
+    },
+    {
+        key: 'common_flux_filter/flux_max',
+        section: 'sky',
+        label: 'Fluxo máximo (Jy)',
+        tooltip: 'Fluxo máximo permitido pelo filtro, em Jy. "max" desativa.',
+        type: 'text',
+        defaultValue: 'max',
+        category: 'advanced'
+    },
+    {
+        key: 'zero_failed_gaussians',
+        section: 'sky',
+        label: 'Zerar Gaussianas falhas',
+        tooltip: 'Se true, fontes com parâmetros Gaussianos inválidos são removidas em vez de modeladas como pontuais.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'apply_horizon_clip',
+        section: 'sky',
+        label: 'Recorte no horizonte',
+        tooltip: 'Recorta fontes abaixo do horizonte. Útil para modelos de céu inteiro. Desative para modelos locais.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'output_text_file',
+        section: 'sky',
+        label: 'Saída sky model (texto)',
+        tooltip: 'Caminho para salvar o modelo de céu final como arquivo texto (útil para depuração).',
+        type: 'text',
+        defaultValue: '',
+        category: 'advanced',
+        isFilePath: true
     },
 
     // =========================================================================
     // [observation]
     // =========================================================================
     {
-        key: 'start_frequency_hz',
+        key: 'mode',
         section: 'observation',
-        label: 'Frequência inicial (Hz)',
-        tooltip: 'Frequência central do primeiro canal de observação, em Hertz. ' +
-                 'Para o BINGO, a faixa de operação é de 980 MHz a 1260 MHz. ' +
-                 'Exemplo: 980000000 para 980 MHz.',
+        label: 'Modo de observação',
+        tooltip: '"Tracking" acompanha uma posição fixa no céu. ' +
+                 '"Drift Scan" mantém o telescópio fixo (modo típico do BINGO).',
+        type: 'select',
+        defaultValue: 'Tracking',
+        category: 'recommended',
+        options: [
+            { value: 'Tracking', label: 'Tracking (rastreio)' },
+            { value: 'Drift Scan', label: 'Drift Scan (trânsito)' }
+        ]
+    },
+    {
+        key: 'phase_centre_ra_deg',
+        section: 'observation',
+        label: 'Centro de fase - AR (graus)',
+        tooltip: 'Ascensão reta do centro de fase, em graus decimais.',
         type: 'number',
-        defaultValue: 980000000,
+        defaultValue: 0.0,
         category: 'essential',
         required: true
     },
     {
-        key: 'num_channels',
+        key: 'phase_centre_dec_deg',
         section: 'observation',
-        label: 'Número de canais',
-        tooltip: 'Quantidade de canais de frequência na observação. Cada canal é separado pelo ' +
-                 'incremento de frequência definido abaixo. Para o BINGO com banda de 280 MHz ' +
-                 'e resolução de 1 MHz, use 280 canais.',
+        label: 'Centro de fase - Dec (graus)',
+        tooltip: 'Declinação do centro de fase, em graus decimais. Valores: -90 a +90.',
         type: 'number',
-        defaultValue: 1,
+        defaultValue: -7.04,
         category: 'essential',
         required: true
     },
     {
-        key: 'frequency_inc_hz',
+        key: 'pointing_file',
         section: 'observation',
-        label: 'Incremento de frequência (Hz)',
-        tooltip: 'Separação entre canais de frequência consecutivos, em Hertz. ' +
-                 'Define a resolução espectral da simulação. ' +
-                 'Exemplo: 1000000 para incrementos de 1 MHz.',
-        type: 'number',
-        defaultValue: 1000000,
-        category: 'recommended'
+        label: 'Arquivo de apontamento',
+        tooltip: 'Caminho para arquivo de apontamento de estação (opcional). Sobrescreve direção de feixe.',
+        type: 'text',
+        defaultValue: '',
+        category: 'advanced',
+        isFilePath: true
     },
     {
-        key: 'phase_centre_ra_deg',
+        key: 'start_frequency_hz',
         section: 'observation',
-        label: 'Centro de fase - AR (graus)',
-        tooltip: 'Ascensão reta do centro de fase da observação, em graus decimais. ' +
-                 'Define a direção de apontamento do telescópio no eixo de ascensão reta. ' +
-                 'Para trânsito no meridiano, use 0.0.',
+        label: 'Frequência inicial (Hz)',
+        tooltip: 'Frequência central do primeiro canal, em Hz. BINGO: 980 MHz a 1260 MHz.',
         type: 'number',
-        defaultValue: 0.0,
+        defaultValue: 980000000,
         category: 'essential',
         required: true
     },
     {
-        key: 'phase_centre_dec_deg',
+        key: 'num_channels',
         section: 'observation',
-        label: 'Centro de fase - Dec (graus)',
-        tooltip: 'Declinação do centro de fase da observação, em graus decimais. ' +
-                 'Para o BINGO, a declinação típica de apontamento é próxima da latitude ' +
-                 'do sítio (-7.04°). Valores válidos: -90 a +90.',
+        label: 'Número de canais',
+        tooltip: 'Quantidade de canais de frequência. BINGO com 280 MHz e resolução 1 MHz → 280.',
         type: 'number',
-        defaultValue: -7.04,
+        defaultValue: 1,
         category: 'essential',
         required: true
     },
+    {
+        key: 'frequency_inc_hz',
+        section: 'observation',
+        label: 'Incremento de frequência (Hz)',
+        tooltip: 'Separação entre canais consecutivos, em Hz.',
+        type: 'number',
+        defaultValue: 1000000,
+        category: 'recommended'
+    },
     {
         key: 'start_time_utc',
         section: 'observation',
         label: 'Hora de início (UTC)',
-        tooltip: 'Data e hora de início da observação no formato UTC. ' +
-                 'Use o formato "dd-MM-yyyy HH:mm:ss.SSS" (ex: "01-01-2025 00:00:00.000"). ' +
-                 'O horário afeta a posição aparente das fontes no céu.',
+        tooltip: 'Data/hora de início no formato "dd-MM-yyyy HH:mm:ss.SSS".',
         type: 'text',
         defaultValue: '01-01-2025 00:00:00.000',
         category: 'essential',
@@ -163,9 +408,7 @@ const OSKAR_INI_PARAMS = Object.freeze([
         key: 'length',
         section: 'observation',
         label: 'Duração da observação (s)',
-        tooltip: 'Duração total da observação em segundos. ' +
-                 'Exemplo: 3600 para uma observação de 1 hora, 86400 para 24 horas. ' +
-                 'A duração afeta a cobertura (u,v) do interferômetro.',
+        tooltip: 'Duração total em segundos. Ex: 3600 = 1 hora.',
         type: 'number',
         defaultValue: 3600,
         category: 'essential',
@@ -175,127 +418,213 @@ const OSKAR_INI_PARAMS = Object.freeze([
         key: 'num_time_steps',
         section: 'observation',
         label: 'Número de passos de tempo',
-        tooltip: 'Quantidade de amostras temporais dentro da duração total da observação. ' +
-                 'O intervalo de integração será duração/num_time_steps. ' +
-                 'Mais passos melhoram a cobertura (u,v), mas aumentam o tempo de simulação.',
+        tooltip: 'Amostras temporais na observação. Mais passos = melhor cobertura UV.',
         type: 'number',
         defaultValue: 24,
         category: 'essential',
         required: true
     },
-    {
-        key: 'mode',
-        section: 'observation',
-        label: 'Modo de observação',
-        tooltip: 'Modo de operação do telescópio durante a observação. ' +
-                 '"Tracking" acompanha uma posição fixa no céu (modo padrão para interferômetros). ' +
-                 '"Drift Scan" mantém o telescópio fixo enquanto o céu se move (modo típico do BINGO).',
-        type: 'select',
-        defaultValue: 'Tracking',
-        category: 'recommended',
-        options: [
-            { value: 'Tracking', label: 'Tracking (rastreio)' },
-            { value: 'Drift Scan', label: 'Drift Scan (trânsito)' }
-        ]
-    },
 
     // =========================================================================
     // [telescope]
     // =========================================================================
     {
-        key: 'input_dir',
+        key: 'input_directory',
         section: 'telescope',
         label: 'Diretório do telescópio',
-        tooltip: 'Caminho para o diretório contendo os arquivos de definição do telescópio OSKAR. ' +
-                 'Este diretório deve conter layout.txt, position.txt e subdiretórios das estações. ' +
-                 'Use o módulo de exportação para gerar estes arquivos.',
+        tooltip: 'Caminho para o diretório com os arquivos de definição do telescópio OSKAR.',
         type: 'text',
         defaultValue: '',
         category: 'essential',
-        required: true
+        required: true,
+        isFilePath: true,
+        isDirectory: true
     },
     {
-        key: 'longitude_deg',
+        key: 'normalise_beams_at_phase_centre',
         section: 'telescope',
-        label: 'Longitude do telescópio (graus)',
-        tooltip: 'Longitude geodésica do centro de referência do telescópio, em graus decimais. ' +
-                 'Para o BINGO, a longitude é ' + INI_BINGO_LONGITUDE + '° (Paraíba, Brasil). ' +
-                 'Usada para converter coordenadas locais em celestes.',
-        type: 'number',
-        defaultValue: INI_BINGO_LONGITUDE,
-        category: 'recommended'
+        label: 'Normalizar beams no centro de fase',
+        tooltip: 'Escala amplitude do beam de cada estação para 1.0 no centro de fase.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
     },
     {
-        key: 'latitude_deg',
+        key: 'allow_station_beam_duplication',
         section: 'telescope',
-        label: 'Latitude do telescópio (graus)',
-        tooltip: 'Latitude geodésica do centro de referência do telescópio, em graus decimais. ' +
-                 'Para o BINGO, a latitude é ' + INI_BINGO_LATITUDE + '° (Paraíba, Brasil). ' +
-                 'Usada para converter coordenadas locais em celestes.',
-        type: 'number',
-        defaultValue: INI_BINGO_LATITUDE,
-        category: 'recommended'
+        label: 'Duplicar beams de estações idênticas',
+        tooltip: 'Usa mapa de tipos de estação para duplicar beams. Pode acelerar significativamente.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
     },
     {
         key: 'pol_mode',
         section: 'telescope',
         label: 'Modo de polarização',
-        tooltip: 'Define o modo de polarização simulado. ' +
-                 '"Scalar" simula apenas uma polarização (mais rápido). ' +
-                 '"Full" simula as 4 correlações de polarização (XX, XY, YX, YY).',
+        tooltip: '"Scalar" simula apenas Stokes I (mais rápido). "Full" simula XX, XY, YX, YY.',
         type: 'select',
-        defaultValue: 'Scalar',
-        category: 'advanced',
+        defaultValue: 'Full',
+        category: 'recommended',
         options: [
             { value: 'Scalar', label: 'Scalar (uma polarização)' },
             { value: 'Full', label: 'Full (polarização completa)' }
         ]
     },
+    {
+        key: 'station_type',
+        section: 'telescope',
+        label: 'Tipo de estação',
+        tooltip: 'Tipo de estação: A = Aperture array, G = Gaussian beam, I = Isotropic beam.',
+        type: 'select',
+        defaultValue: 'A',
+        category: 'advanced',
+        options: [
+            { value: 'A', label: 'A (Aperture Array)' },
+            { value: 'G', label: 'G (Gaussian beam)' },
+            { value: 'I', label: 'I (Isotropic beam)' }
+        ]
+    },
+    {
+        key: 'aperture_array/array_pattern/enable',
+        section: 'telescope',
+        label: 'Habilitar array pattern',
+        tooltip: 'Habilita contribuição do array pattern (beamforming) ao beam da estação.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'aperture_array/array_pattern/normalise',
+        section: 'telescope',
+        label: 'Normalizar array pattern',
+        tooltip: 'Se sim, divide amplitude do beam pelo número de antenas na estação.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/enable_numerical',
+        section: 'telescope',
+        label: 'Usar padrão numérico de elemento',
+        tooltip: 'Usa arquivos de padrão numérico de elemento se disponíveis.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/functional_type',
+        section: 'telescope',
+        label: 'Tipo funcional de elemento',
+        tooltip: 'Tipo de padrão funcional aplicado aos elementos (quando não usando padrão numérico).',
+        type: 'select',
+        defaultValue: 'Dipole',
+        category: 'advanced',
+        options: [
+            { value: 'Dipole', label: 'Dipole' },
+            { value: 'Isotropic', label: 'Isotropic' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/dipole_length',
+        section: 'telescope',
+        label: 'Comprimento do dipolo',
+        tooltip: 'Comprimento do dipolo (na unidade definida abaixo).',
+        type: 'number',
+        defaultValue: 0.5,
+        category: 'advanced'
+    },
+    {
+        key: 'aperture_array/element_pattern/dipole_length_units',
+        section: 'telescope',
+        label: 'Unidade do comprimento do dipolo',
+        tooltip: 'Unidade para especificar o comprimento do dipolo.',
+        type: 'select',
+        defaultValue: 'Wavelengths',
+        category: 'advanced',
+        options: [
+            { value: 'Wavelengths', label: 'Comprimentos de onda' },
+            { value: 'Metres', label: 'Metros' }
+        ]
+    },
+    {
+        key: 'gaussian_beam/fwhm_deg',
+        section: 'telescope',
+        label: 'FWHM do beam Gaussiano (°)',
+        tooltip: 'Largura a meia-altura do beam Gaussiano na freq. de referência, em graus.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'gaussian_beam/ref_freq_hz',
+        section: 'telescope',
+        label: 'Freq. referência do beam Gaussiano (Hz)',
+        tooltip: 'Frequência de referência do FWHM especificado, em Hz.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'ionosphere_screen_type',
+        section: 'telescope',
+        label: 'Tipo de tela ionosférica',
+        tooltip: 'Tipo de tela de fase ionosférica. "None" desativa.',
+        type: 'select',
+        defaultValue: 'None',
+        category: 'advanced',
+        options: [
+            { value: 'None', label: 'None (desativado)' },
+            { value: 'External', label: 'External (arquivo FITS)' }
+        ]
+    },
 
     // =========================================================================
     // [interferometer]
     // =========================================================================
-    {
-        key: 'oskar_vis_filename',
-        section: 'interferometer',
-        label: 'Arquivo de visibilidades',
-        tooltip: 'Caminho e nome do arquivo de saída para as visibilidades simuladas (.vis). ' +
-                 'Este arquivo conterá os dados de correlação cruzada entre todas as linhas de base. ' +
-                 'Exemplo: "output/bingo_sim.vis".',
-        type: 'text',
-        defaultValue: 'output/bingo_sim.vis',
-        category: 'essential',
-        required: true
-    },
     {
         key: 'channel_bandwidth_hz',
         section: 'interferometer',
         label: 'Largura de banda do canal (Hz)',
-        tooltip: 'Largura de banda de cada canal de frequência individual, em Hertz. ' +
-                 'Usado para a decorrelação em largura de banda (bandwidth smearing). ' +
-                 'Geralmente igual ao incremento de frequência.',
+        tooltip: 'Largura de cada canal para simular bandwidth smearing.',
         type: 'number',
-        defaultValue: 1000000,
+        defaultValue: 0,
         category: 'recommended'
     },
     {
         key: 'time_average_sec',
         section: 'interferometer',
         label: 'Média temporal (s)',
-        tooltip: 'Intervalo de média temporal das visibilidades, em segundos. ' +
-                 'Usado para simular a decorrelação temporal (time smearing). ' +
-                 'Valores típicos: 1 a 10 segundos.',
+        tooltip: 'Duração de média temporal do correlacionador, em segundos.',
         type: 'number',
-        defaultValue: 1.0,
+        defaultValue: 0.0,
         category: 'recommended'
     },
     {
         key: 'max_time_samples_per_block',
         section: 'interferometer',
         label: 'Amostras por bloco',
-        tooltip: 'Número máximo de amostras temporais processadas por bloco na correlação. ' +
-                 'Valores maiores usam mais memória. Reduza se a GPU ficar sem memória. ' +
-                 'Valor padrão de 8 é adequado para a maioria dos casos.',
+        tooltip: 'Máximo de amostras temporais por bloco antes de escrever em disco.',
         type: 'number',
         defaultValue: 8,
         category: 'advanced'
@@ -304,18 +633,137 @@ const OSKAR_INI_PARAMS = Object.freeze([
         key: 'correlation_type',
         section: 'interferometer',
         label: 'Tipo de correlação',
-        tooltip: 'Define quais correlações são calculadas. ' +
-                 '"Cross-correlations" calcula apenas linhas de base cruzadas (padrão para interferometria). ' +
-                 '"Auto-correlations" calcula apenas auto-correlações. ' +
-                 '"Both" calcula ambas.',
+        tooltip: 'Tipo de correlações calculadas.',
         type: 'select',
         defaultValue: 'Cross-correlations',
-        category: 'advanced',
+        category: 'recommended',
         options: [
             { value: 'Cross-correlations', label: 'Cross-correlations (cruzadas)' },
             { value: 'Auto-correlations', label: 'Auto-correlations (auto)' },
             { value: 'Both', label: 'Both (ambas)' }
         ]
+    },
+    {
+        key: 'uv_filter_min',
+        section: 'interferometer',
+        label: 'Filtro UV mínimo',
+        tooltip: 'Comprimento UV mínimo permitido. Baselines menores não são avaliadas.',
+        type: 'text',
+        defaultValue: 'min',
+        category: 'advanced'
+    },
+    {
+        key: 'uv_filter_max',
+        section: 'interferometer',
+        label: 'Filtro UV máximo',
+        tooltip: 'Comprimento UV máximo permitido. Baselines maiores não são avaliadas.',
+        type: 'text',
+        defaultValue: 'max',
+        category: 'advanced'
+    },
+    {
+        key: 'uv_filter_units',
+        section: 'interferometer',
+        label: 'Unidade do filtro UV',
+        tooltip: 'Unidade dos valores de filtro UV.',
+        type: 'select',
+        defaultValue: 'Wavelengths',
+        category: 'advanced',
+        options: [
+            { value: 'Wavelengths', label: 'Comprimentos de onda (W)' },
+            { value: 'Metres', label: 'Metros' }
+        ]
+    },
+    {
+        key: 'oskar_vis_filename',
+        section: 'interferometer',
+        label: 'Arquivo de visibilidades (.vis)',
+        tooltip: 'Caminho do arquivo de saída OSKAR visibility (.vis).',
+        type: 'text',
+        defaultValue: 'output/bingo_sim.vis',
+        category: 'essential',
+        required: true,
+        isFilePath: true
+    },
+    {
+        key: 'ms_filename',
+        section: 'interferometer',
+        label: 'Arquivo Measurement Set (.ms)',
+        tooltip: 'Caminho do Measurement Set de saída. Deixe em branco se não necessário.',
+        type: 'text',
+        defaultValue: '',
+        category: 'recommended',
+        isFilePath: true
+    },
+    {
+        key: 'force_polarised_ms',
+        section: 'interferometer',
+        label: 'Forçar MS polarizado',
+        tooltip: 'Se sim, escreve o MS sempre em formato polarizado mesmo no modo Scalar.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'ignore_w_components',
+        section: 'interferometer',
+        label: 'Ignorar componentes W',
+        tooltip: 'Se habilitado, zera coordenadas W das baselines. Desativa W-smearing.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+
+    // =========================================================================
+    // [noise]
+    // =========================================================================
+    {
+        key: 'enable',
+        section: 'noise',
+        label: 'Habilitar ruído',
+        tooltip: 'Se habilitado, adiciona ruído térmico à simulação.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'seed',
+        section: 'noise',
+        label: 'Semente do ruído',
+        tooltip: 'Semente do gerador de números aleatórios para o ruído.',
+        type: 'number',
+        defaultValue: 1,
+        category: 'advanced'
+    },
+    {
+        key: 'rms/start',
+        section: 'noise',
+        label: 'RMS início (Jy)',
+        tooltip: 'Valor RMS de início da faixa de ruído por estação, em Jy.',
+        type: 'number',
+        defaultValue: 0,
+        category: 'advanced'
+    },
+    {
+        key: 'rms/end',
+        section: 'noise',
+        label: 'RMS fim (Jy)',
+        tooltip: 'Valor RMS de fim da faixa de ruído por estação, em Jy.',
+        type: 'number',
+        defaultValue: 0,
+        category: 'advanced'
     }
 ]);
 
@@ -328,7 +776,8 @@ const INI_SECTION_LABELS = Object.freeze({
     sky: 'Modelo de Céu',
     observation: 'Observação',
     telescope: 'Telescópio',
-    interferometer: 'Interferômetro'
+    interferometer: 'Interferômetro',
+    noise: 'Ruído'
 });
 
 /**
@@ -376,10 +825,12 @@ class OskarIniGenerator {
         const copyBtn = document.getElementById('ini-copy-btn');
         const downloadBtn = document.getElementById('ini-download-btn');
         const fillBtn = document.getElementById('ini-fill-from-layout-btn');
+        const useSkyBtn = document.getElementById('ini-use-sky-model-btn');
 
         if (copyBtn) copyBtn.addEventListener('click', (e) => { e.preventDefault(); this.copyIni(); });
         if (downloadBtn) downloadBtn.addEventListener('click', (e) => { e.preventDefault(); this.downloadIni(); });
         if (fillBtn) fillBtn.addEventListener('click', (e) => { e.preventDefault(); this.fillFromLayout(); });
+        if (useSkyBtn) useSkyBtn.addEventListener('click', (e) => { e.preventDefault(); this.useSkyModel(); });
     }
 
     // =========================================================================
@@ -429,7 +880,7 @@ class OskarIniGenerator {
             }
 
             // Agrupa parâmetros desta categoria por seção
-            const sectionOrder = ['simulator', 'sky', 'observation', 'telescope', 'interferometer'];
+            const sectionOrder = ['simulator', 'sky', 'observation', 'telescope', 'interferometer', 'noise'];
             const grouped = {};
             params.forEach(p => {
                 if (!grouped[p.section]) grouped[p.section] = [];
@@ -526,7 +977,56 @@ class OskarIniGenerator {
         this.inputElements[compositeKey] = input;
 
         row.appendChild(label);
-        row.appendChild(input);
+
+        // Para campos de arquivo/diretório, cria um wrapper com botão de browse
+        if (param.isFilePath) {
+            const inputWrapper = document.createElement('div');
+            inputWrapper.className = 'ini-file-input-wrapper';
+            inputWrapper.appendChild(input);
+
+            const browseBtn = document.createElement('button');
+            browseBtn.type = 'button';
+            browseBtn.className = 'ini-browse-btn';
+            browseBtn.title = 'Selecionar arquivo do computador';
+            browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
+
+            const hiddenFileInput = document.createElement('input');
+            hiddenFileInput.type = 'file';
+            hiddenFileInput.style.display = 'none';
+            if (param.isDirectory) {
+                hiddenFileInput.setAttribute('webkitdirectory', '');
+            }
+            if (param.fileAccept) {
+                hiddenFileInput.accept = param.fileAccept;
+            }
+
+            browseBtn.addEventListener('click', (e) => {
+                e.preventDefault();
+                hiddenFileInput.click();
+            });
+
+            hiddenFileInput.addEventListener('change', (ev) => {
+                if (ev.target.files && ev.target.files.length > 0) {
+                    // Usa webkitRelativePath se disponível (diretório), senão name
+                    const file = ev.target.files[0];
+                    const path = file.webkitRelativePath || file.name;
+                    // Para diretório, usa o primeiro segmento do caminho
+                    if (param.isDirectory && file.webkitRelativePath) {
+                        input.value = file.webkitRelativePath.split('/')[0];
+                    } else {
+                        input.value = path;
+                    }
+                    input.dispatchEvent(new Event('input'));
+                }
+            });
+
+            inputWrapper.appendChild(browseBtn);
+            inputWrapper.appendChild(hiddenFileInput);
+            row.appendChild(inputWrapper);
+        } else {
+            row.appendChild(input);
+        }
+
         row.appendChild(errorSpan);
         return row;
     }
@@ -561,10 +1061,15 @@ class OskarIniGenerator {
             sections[param.section].push({ key: param.key, value });
         });
 
-        // Monta string INI
-        const sectionOrder = ['simulator', 'sky', 'observation', 'telescope', 'interferometer'];
+        // Monta string INI com [General] no topo
+        const sectionOrder = ['simulator', 'sky', 'observation', 'telescope', 'interferometer', 'noise'];
         const lines = [];
 
+        // Seção [General] obrigatória no topo
+        lines.push('[General]');
+        lines.push('app=oskar_sim_interferometer');
+        lines.push('');
+
         sectionOrder.forEach(sec => {
             if (!sections[sec] || sections[sec].length === 0) return;
             lines.push(`[${sec}]`);
@@ -709,20 +1214,13 @@ class OskarIniGenerator {
      * Preenche os campos do telescópio a partir dos dados do layout/mapa atuais.
      */
     fillFromLayout() {
-        // Longitude e latitude do BINGO
-        const lonInput = this.inputElements['telescope.longitude_deg'];
-        const latInput = this.inputElements['telescope.latitude_deg'];
-
-        if (lonInput) { lonInput.value = INI_BINGO_LONGITUDE; }
-        if (latInput) { latInput.value = INI_BINGO_LATITUDE; }
-
-        // Tenta obter o diretório de exportação se disponível
-        const dirInput = this.inputElements['telescope.input_dir'];
+        // Diretório do telescópio
+        const dirInput = this.inputElements['telescope.input_directory'];
         if (dirInput && !dirInput.value) {
             dirInput.value = 'telescope';
         }
 
-        // Declinação aproximada = latitude
+        // Declinação aproximada = latitude do BINGO
         const decInput = this.inputElements['observation.phase_centre_dec_deg'];
         if (decInput) {
             decInput.value = INI_BINGO_LATITUDE;
@@ -738,12 +1236,29 @@ class OskarIniGenerator {
         console.log('Campos preenchidos a partir dos dados do layout BINGO.');
     }
 
+    /**
+     * Preenche o campo sky model com o nome do arquivo gerado na aba Sky Model.
+     */
+    useSkyModel() {
+        const skyInput = this.inputElements['sky.oskar_sky_model/file'];
+        if (skyInput) {
+            if (window.skyModelGenerator && window.skyModelGenerator.sources.length > 0) {
+                skyInput.value = 'bingo_sky_model.osm';
+                this.updatePreview();
+                console.log('Campo sky model preenchido com o modelo de céu gerado.');
+            } else {
+                alert('Nenhuma fonte foi gerada no Modelo de Céu. Vá à aba "Modelo de Céu" e adicione fontes primeiro.');
+            }
+        }
+    }
+
     // =========================================================================
     // Download e cópia
     // =========================================================================
 
     /**
      * Faz o download do arquivo .ini gerado.
+     * Se houver um sky model gerado, baixa ambos em um ZIP.
      */
     downloadIni() {
         if (!this.validateFields()) {
@@ -751,18 +1266,56 @@ class OskarIniGenerator {
             return;
         }
 
-        const content = this.generateIni();
+        const iniContent = this.generateIni();
+
+        // Verifica se há sky model disponível para bundling
+        const skyModelContent = (window.skyModelGenerator && window.skyModelGenerator.sources.length > 0)
+            ? window.skyModelGenerator.exportOskarFormat()
+            : null;
+
+        if (skyModelContent && typeof JSZip !== 'undefined') {
+            // Baixa ambos em um ZIP
+            const zip = new JSZip();
+            zip.file('oskar_sim.ini', iniContent);
+            zip.file('bingo_sky_model.osm', skyModelContent);
+
+            zip.generateAsync({ type: 'blob' }).then(blob => {
+                const url = URL.createObjectURL(blob);
+                const a = document.createElement('a');
+                a.href = url;
+                a.download = 'oskar_config.zip';
+                document.body.appendChild(a);
+                a.click();
+                document.body.removeChild(a);
+                URL.revokeObjectURL(url);
+                console.log('Arquivo ZIP (INI + Sky Model) baixado com sucesso.');
+            }).catch(err => {
+                console.error('Erro ao gerar ZIP:', err);
+                // Fallback: download apenas o INI
+                this._downloadSingleFile(iniContent, 'oskar_sim.ini');
+            });
+        } else {
+            this._downloadSingleFile(iniContent, 'oskar_sim.ini');
+        }
+    }
+
+    /**
+     * Faz download de um único arquivo de texto.
+     * @private
+     * @param {string} content Conteúdo do arquivo.
+     * @param {string} filename Nome do arquivo.
+     */
+    _downloadSingleFile(content, filename) {
         const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
         const url = URL.createObjectURL(blob);
         const a = document.createElement('a');
         a.href = url;
-        a.download = 'oskar_sim.ini';
+        a.download = filename;
         document.body.appendChild(a);
         a.click();
         document.body.removeChild(a);
         URL.revokeObjectURL(url);
-
-        console.log('Arquivo .ini baixado com sucesso.');
+        console.log(`Arquivo ${filename} baixado com sucesso.`);
     }
 
     /**
diff --git a/js/map.js b/js/map.js
index df10dc8..6cea377 100644
--- a/js/map.js
+++ b/js/map.js
@@ -51,6 +51,7 @@ class InteractiveMap {
         this.activeMarkerIndex = -1;
 
         this.arrangementLayer = L.featureGroup();
+        this.distanceLinesLayer = L.featureGroup(); // Camada para linhas de distância (oculta por padrão)
         this.isArrangementLayerActive = false;
         this.activeBaseLayerName = '';
         this.layersControl = null;
@@ -137,6 +138,7 @@ class InteractiveMap {
         };
         const overlayMaps = {
             "Nomes e Limites (ESRI)": labelsLayer,
+            "Mostrar distâncias ao BINGO": this.distanceLinesLayer,
             "Visualizar o Arranjo": this.arrangementLayer
         };
 
@@ -216,7 +218,7 @@ class InteractiveMap {
         window.addEventListener('themeChanged', () => {
             const newPrimaryColor = getComputedStyle(document.documentElement).getPropertyValue('--primary-color').trim() || 'blue';
             this.distanceLines.forEach(line => {
-                if (this.map.hasLayer(line)) {
+                if (this.distanceLinesLayer.hasLayer(line)) {
                     line.setStyle({ color: newPrimaryColor });
                 }
             });
@@ -324,7 +326,8 @@ class InteractiveMap {
         const line = L.polyline([[lat, lng], [BINGO_LATITUDE, BINGO_LONGITUDE]], {
             color: getComputedStyle(document.documentElement).getPropertyValue('--primary-color').trim() || 'blue',
             weight: 2, opacity: 0.7, dashArray: '5, 5'
-        }).addTo(this.map);
+        });
+        this.distanceLinesLayer.addLayer(line);
 
         const tooltip = L.tooltip({ permanent: true, direction: 'center', className: 'distance-tooltip', offset: [0, -7] });
         const midPoint = this.calculateMidpoint(lat, lng, BINGO_LATITUDE, BINGO_LONGITUDE);
@@ -475,7 +478,7 @@ class InteractiveMap {
         if (index >= 0 && index < this.stationMarkers.length) {
             const removedName = this.selectedCoordinates[index].name;
             this.map.removeLayer(this.stationMarkers[index]);
-            this.map.removeLayer(this.distanceLines[index]);
+            this.distanceLinesLayer.removeLayer(this.distanceLines[index]);
             this.stationMarkers.splice(index, 1);
             this.distanceLines.splice(index, 1);
             this.selectedCoordinates.splice(index, 1);

From 0f16dc2d15062c78a481998ad2662e43aae209ef Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 10 Feb 2026 23:11:18 +0000
Subject: [PATCH 14/22] Fix syntax error in downloadIni method and add JSZip
 warning

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/ini_generator.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/js/ini_generator.js b/js/ini_generator.js
index 831b0f0..20d0b9d 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -1291,10 +1291,12 @@ class OskarIniGenerator {
                 console.log('Arquivo ZIP (INI + Sky Model) baixado com sucesso.');
             }).catch(err => {
                 console.error('Erro ao gerar ZIP:', err);
-                // Fallback: download apenas o INI
                 this._downloadSingleFile(iniContent, 'oskar_sim.ini');
             });
         } else {
+            if (skyModelContent && typeof JSZip === 'undefined') {
+                console.warn('JSZip não disponível. Baixando apenas o arquivo .ini (sem sky model).');
+            }
             this._downloadSingleFile(iniContent, 'oskar_sim.ini');
         }
     }

From 199abd7db67f21511023999df38a5ec20802b3b7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 00:04:15 +0000
Subject: [PATCH 15/22] Fix UV chart vertical positioning, file selector popup,
 CRLF line endings, and add oskar_imager INI block

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css      |   9 +-
 index.html          |  22 ++
 js/ini_generator.js | 823 ++++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 830 insertions(+), 24 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index 031700d..7daced4 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -1279,7 +1279,7 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
     border-radius: 4px;
     background-color: var(--plot-bg-color);
     display: flex;
-    align-items: center;
+    align-items: flex-start;
     justify-content: center;
     overflow: hidden;
     position: relative;
@@ -1289,6 +1289,13 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
     width: 100% !important;
     max-width: 100%;
 }
+.uv-plot-container .js-plotly-plot .plotly {
+    width: 100% !important;
+    height: 100% !important;
+}
+.uv-plot-container .svg-container {
+    width: 100% !important;
+}
 .uv-plot-container .plot-placeholder {
     font-style: italic;
     opacity: 0.6;
diff --git a/index.html b/index.html
index 2d21e94..d4a409f 100644
--- a/index.html
+++ b/index.html
@@ -497,6 +497,28 @@ <h3>Preview do arquivo .ini</h3>
                     </div>
                 </div>
             </section>
+
+            <!-- === BLOCO 2: OSKAR IMAGER (.ini) === -->
+            <section class="ini-generator-section" style="margin-top: 30px;">
+                <h2><i class="fas fa-image"></i> Gerador de Arquivo do Imager (.ini)</h2>
+                <p class="section-description">Monte o arquivo <code>.ini</code> de configuração do <strong>oskar_imager</strong>. Configura a geração de imagens a partir dos dados de visibilidade simulados.</p>
+                <div class="ini-layout">
+                    <div class="ini-params-area">
+                        <div id="imager-params-container" class="ini-params-container">
+                            <p class="placeholder-text">Carregando parâmetros do imager...</p>
+                        </div>
+                        <div id="imager-validation-messages" class="validation-messages"></div>
+                    </div>
+                    <div class="ini-preview-area">
+                        <h3>Preview do arquivo oskar_imager.ini</h3>
+                        <textarea id="imager-preview" readonly placeholder="O conteúdo do arquivo .ini do imager aparecerá aqui..."></textarea>
+                        <div class="ini-actions">
+                            <button id="imager-copy-btn" class="secondary small-btn"><i class="fas fa-copy"></i> Copiar</button>
+                            <button id="imager-download-btn" class="primary small-btn"><i class="fas fa-download"></i> Baixar oskar_imager.ini</button>
+                        </div>
+                    </div>
+                </div>
+            </section>
         </div><!-- Fim #tab-oskar-config -->
 
         <!-- === ABA 3: MODELO DE CÉU === -->
diff --git a/js/ini_generator.js b/js/ini_generator.js
index 20d0b9d..e740f9a 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -987,15 +987,16 @@ class OskarIniGenerator {
             const browseBtn = document.createElement('button');
             browseBtn.type = 'button';
             browseBtn.className = 'ini-browse-btn';
-            browseBtn.title = 'Selecionar arquivo do computador';
+            browseBtn.title = param.isDirectory
+                ? 'Selecionar pasta do computador'
+                : 'Selecionar arquivo do computador';
             browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
 
+            // Para diretórios, usa um input de arquivo regular (sem webkitdirectory)
+            // para evitar popup de confirmação do navegador e obter caminho completo
             const hiddenFileInput = document.createElement('input');
             hiddenFileInput.type = 'file';
             hiddenFileInput.style.display = 'none';
-            if (param.isDirectory) {
-                hiddenFileInput.setAttribute('webkitdirectory', '');
-            }
             if (param.fileAccept) {
                 hiddenFileInput.accept = param.fileAccept;
             }
@@ -1007,15 +1008,15 @@ class OskarIniGenerator {
 
             hiddenFileInput.addEventListener('change', (ev) => {
                 if (ev.target.files && ev.target.files.length > 0) {
-                    // Usa webkitRelativePath se disponível (diretório), senão name
                     const file = ev.target.files[0];
-                    const path = file.webkitRelativePath || file.name;
-                    // Para diretório, usa o primeiro segmento do caminho
-                    if (param.isDirectory && file.webkitRelativePath) {
-                        input.value = file.webkitRelativePath.split('/')[0];
-                    } else {
-                        input.value = path;
+                    // Tenta extrair o caminho completo via webkitRelativePath
+                    // Navegadores limitam acesso ao caminho completo por segurança
+                    // Usamos o nome do arquivo e o caminho relativo quando disponível
+                    let filePath = file.name;
+                    if (file.webkitRelativePath) {
+                        filePath = file.webkitRelativePath;
                     }
+                    input.value = filePath;
                     input.dispatchEvent(new Event('input'));
                 }
             });
@@ -1035,11 +1036,23 @@ class OskarIniGenerator {
     // Geração do conteúdo INI
     // =========================================================================
 
+    /**
+     * Detecta se o sistema operacional é Windows para usar CRLF.
+     * @private
+     * @returns {string} Quebra de linha adequada ('\r\n' para Windows, '\n' para outros).
+     */
+    _getLineEnding() {
+        const isWindows = (typeof navigator !== 'undefined') &&
+            (navigator.platform?.indexOf('Win') >= 0 || /Windows/i.test(navigator.userAgent || ''));
+        return isWindows ? '\r\n' : '\n';
+    }
+
     /**
      * Gera o conteúdo completo do arquivo .ini a partir dos valores atuais.
      * @returns {string} Conteúdo formatado do arquivo .ini.
      */
     generateIni() {
+        const eol = this._getLineEnding();
         const sections = {};
 
         OSKAR_INI_PARAMS.forEach(param => {
@@ -1079,7 +1092,7 @@ class OskarIniGenerator {
             lines.push(''); // linha em branco entre seções
         });
 
-        return lines.join('\n');
+        return lines.join(eol);
     }
 
     // =========================================================================
@@ -1382,18 +1395,782 @@ class OskarIniGenerator {
 }
 
 // =============================================================================
-// Inicialização
+// OSKAR Imager - Parâmetros e Gerador
 // =============================================================================
 
-document.addEventListener('DOMContentLoaded', () => {
-    if (!window.oskarIniGenerator) {
-        try {
-            window.oskarIniGenerator = new OskarIniGenerator();
-            console.log('Instância de OskarIniGenerator criada e configurada.');
-        } catch (error) {
-            console.error('Erro ao instanciar OskarIniGenerator:', error);
-        }
-    } else {
-        window.oskarIniGenerator.updatePreview();
+/**
+ * Definição dos parâmetros do oskar_imager.
+ * @constant {Array<Object>}
+ */
+const OSKAR_IMAGER_PARAMS = Object.freeze([
+    // =========================================================================
+    // [image] - Configuração geral
+    // =========================================================================
+    {
+        key: 'double_precision',
+        section: 'image',
+        label: 'Precisão dupla',
+        tooltip: 'Ativa cálculos em precisão dupla (64 bits).',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'use_gpus',
+        section: 'image',
+        label: 'Usar GPUs',
+        tooltip: 'Se habilitado, usa dispositivos GPU disponíveis.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'cuda_device_ids',
+        section: 'image',
+        label: 'IDs de dispositivos CUDA',
+        tooltip: 'Lista separada por vírgulas de IDs de GPUs, ou "all" para usar todos.',
+        type: 'text',
+        defaultValue: 'all',
+        category: 'advanced'
+    },
+    {
+        key: 'num_devices',
+        section: 'image',
+        label: 'Número de dispositivos',
+        tooltip: 'Número de dispositivos de computação (CPU cores ou GPUs). "auto" detecta.',
+        type: 'text',
+        defaultValue: 'auto',
+        category: 'advanced'
+    },
+    {
+        key: 'specify_cellsize',
+        section: 'image',
+        label: 'Especificar tamanho de célula',
+        tooltip: 'Se habilitado, especifica o tamanho da célula em arcsec; caso contrário, usa FOV.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim (cellsize)' },
+            { value: 'false', label: 'Não (FOV)' }
+        ]
+    },
+    {
+        key: 'fov_deg',
+        section: 'image',
+        label: 'Campo de visão (°)',
+        tooltip: 'Campo de visão total da imagem em graus.',
+        type: 'number',
+        defaultValue: 2.0,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'cellsize_arcsec',
+        section: 'image',
+        label: 'Tamanho da célula (arcsec)',
+        tooltip: 'Tamanho do pixel em segundos de arco. Usado se specify_cellsize = true.',
+        type: 'number',
+        defaultValue: 1.0,
+        category: 'recommended'
+    },
+    {
+        key: 'size',
+        section: 'image',
+        label: 'Tamanho da imagem (pixels)',
+        tooltip: 'Largura da imagem em pixels (deve ser par). Ex: 256 gera imagem 256×256.',
+        type: 'number',
+        defaultValue: 256,
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'image_type',
+        section: 'image',
+        label: 'Tipo de imagem',
+        tooltip: 'Tipo de imagem a gerar. I, Q, U, V são parâmetros de Stokes. PSF gera a função de espalhamento pontual.',
+        type: 'select',
+        defaultValue: 'I',
+        category: 'essential',
+        required: true,
+        options: [
+            { value: 'I', label: 'Stokes I' },
+            { value: 'Q', label: 'Stokes Q' },
+            { value: 'U', label: 'Stokes U' },
+            { value: 'V', label: 'Stokes V' },
+            { value: 'PSF', label: 'PSF' },
+            { value: 'LINEAR', label: 'Linear (XX, XY, YX, YY)' }
+        ]
+    },
+    {
+        key: 'channel_snapshots',
+        section: 'image',
+        label: 'Snapshots por canal',
+        tooltip: 'Se true, produz cubo de imagens com snapshot por canal. Se false, usa síntese de frequência.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não (síntese)' }
+        ]
+    },
+    {
+        key: 'freq_min_hz',
+        section: 'image',
+        label: 'Frequência mínima (Hz)',
+        tooltip: 'Frequência mínima a incluir na imagem, em Hz. 0.0 = sem filtro.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'freq_max_hz',
+        section: 'image',
+        label: 'Frequência máxima (Hz)',
+        tooltip: 'Frequência máxima a incluir na imagem. "max" = sem limite superior.',
+        type: 'text',
+        defaultValue: 'max',
+        category: 'advanced'
+    },
+    {
+        key: 'time_min_utc',
+        section: 'image',
+        label: 'Tempo mínimo (UTC)',
+        tooltip: 'Tempo mínimo dos dados de visibilidade a incluir. Formato MJD ou dd-MM-yyyy HH:mm:ss.SSS.',
+        type: 'text',
+        defaultValue: '0.0',
+        category: 'advanced'
+    },
+    {
+        key: 'time_max_utc',
+        section: 'image',
+        label: 'Tempo máximo (UTC)',
+        tooltip: 'Tempo máximo dos dados de visibilidade a incluir. Formato MJD ou dd-MM-yyyy HH:mm:ss.SSS.',
+        type: 'text',
+        defaultValue: '0.0',
+        category: 'advanced'
+    },
+    {
+        key: 'uv_filter_min',
+        section: 'image',
+        label: 'Filtro UV mínimo (λ)',
+        tooltip: 'Comprimento mínimo de baseline UV a imagear, em comprimentos de onda.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'uv_filter_max',
+        section: 'image',
+        label: 'Filtro UV máximo (λ)',
+        tooltip: 'Comprimento máximo de baseline UV a imagear. "max" = sem limite.',
+        type: 'text',
+        defaultValue: 'max',
+        category: 'advanced'
+    },
+    {
+        key: 'algorithm',
+        section: 'image',
+        label: 'Algoritmo de transformada',
+        tooltip: 'Tipo de transformada para gerar a imagem.',
+        type: 'select',
+        defaultValue: 'FFT',
+        category: 'recommended',
+        options: [
+            { value: 'FFT', label: 'FFT' },
+            { value: 'DFT 2D', label: 'DFT 2D' },
+            { value: 'DFT 3D', label: 'DFT 3D' },
+            { value: 'W-projection', label: 'W-projection' }
+        ]
+    },
+    {
+        key: 'weighting',
+        section: 'image',
+        label: 'Ponderação (weighting)',
+        tooltip: 'Esquema de ponderação das visibilidades.',
+        type: 'select',
+        defaultValue: 'Natural',
+        category: 'recommended',
+        options: [
+            { value: 'Natural', label: 'Natural' },
+            { value: 'Uniform', label: 'Uniform' },
+            { value: 'Radial', label: 'Radial' }
+        ]
+    },
+    {
+        key: 'weight_taper/u_wavelengths',
+        section: 'image',
+        label: 'Taper em U (λ)',
+        tooltip: 'Escala de tapering em U para pesos, em comprimentos de onda. 0 = desativado.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'weight_taper/v_wavelengths',
+        section: 'image',
+        label: 'Taper em V (λ)',
+        tooltip: 'Escala de tapering em V para pesos, em comprimentos de onda. 0 = desativado.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+
+    // =========================================================================
+    // [image/fft] - Configuração FFT
+    // =========================================================================
+    {
+        key: 'fft/use_gpu',
+        section: 'image',
+        label: 'FFT na GPU',
+        tooltip: 'Se true, usa a GPU para executar a FFT.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'fft/grid_on_gpu',
+        section: 'image',
+        label: 'Gridding na GPU',
+        tooltip: 'Se true, usa a GPU para o gridding das visibilidades.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'fft/kernel_type',
+        section: 'image',
+        label: 'Tipo de kernel de gridding',
+        tooltip: 'Tipo de kernel usado para gridding.',
+        type: 'select',
+        defaultValue: 'Spheroidal',
+        category: 'advanced',
+        options: [
+            { value: 'Spheroidal', label: 'Spheroidal' },
+            { value: 'Pillbox', label: 'Pillbox' }
+        ]
+    },
+    {
+        key: 'fft/support',
+        section: 'image',
+        label: 'Suporte do kernel',
+        tooltip: 'Tamanho do suporte do kernel de gridding.',
+        type: 'number',
+        defaultValue: 3,
+        category: 'advanced'
+    },
+    {
+        key: 'fft/oversample',
+        section: 'image',
+        label: 'Fator de oversampling',
+        tooltip: 'Fator de oversampling do kernel de gridding.',
+        type: 'number',
+        defaultValue: 100,
+        category: 'advanced'
+    },
+
+    // =========================================================================
+    // [image/wproj] - W-projection
+    // =========================================================================
+    {
+        key: 'wproj/generate_w_kernels_on_gpu',
+        section: 'image',
+        label: 'W-kernels na GPU',
+        tooltip: 'Se true, gera os W-kernels na GPU.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'wproj/num_w_planes',
+        section: 'image',
+        label: 'Número de W-planes',
+        tooltip: 'Número de planos W. Valores < 1 significam "automático".',
+        type: 'number',
+        defaultValue: 0,
+        category: 'advanced'
+    },
+
+    // =========================================================================
+    // [image/direction] - Direção da imagem
+    // =========================================================================
+    {
+        key: 'direction',
+        section: 'image',
+        label: 'Direção do centro de fase',
+        tooltip: '"Obs" usa a direção da observação. "RA, Dec." usa valores customizados.',
+        type: 'select',
+        defaultValue: 'Obs',
+        category: 'recommended',
+        options: [
+            { value: 'Obs', label: 'Observação (Obs)' },
+            { value: 'RA, Dec.', label: 'RA, Dec. (customizado)' }
+        ]
+    },
+    {
+        key: 'direction/ra_deg',
+        section: 'image',
+        label: 'RA do centro de fase (°)',
+        tooltip: 'Ascensão reta do centro de fase da imagem, em graus.',
+        type: 'number',
+        defaultValue: 0,
+        category: 'recommended'
+    },
+    {
+        key: 'direction/dec_deg',
+        section: 'image',
+        label: 'Dec do centro de fase (°)',
+        tooltip: 'Declinação do centro de fase da imagem, em graus.',
+        type: 'number',
+        defaultValue: 0,
+        category: 'recommended'
+    },
+
+    // =========================================================================
+    // [image] - Entrada/Saída
+    // =========================================================================
+    {
+        key: 'input_vis_data',
+        section: 'image',
+        label: 'Arquivo de visibilidades de entrada',
+        tooltip: 'Caminho para o arquivo de visibilidades OSKAR (.vis) ou Measurement Set (.ms).',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true,
+        isFilePath: true,
+        fileAccept: '.vis,.ms'
+    },
+    {
+        key: 'scale_norm_with_num_input_files',
+        section: 'image',
+        label: 'Escalar normalização pelo nº de arquivos',
+        tooltip: 'Se true, escala a normalização pelo número de arquivos de entrada. Use true se arquivos representam múltiplos modelos de céu com mesma config de telescópio.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'ms_column',
+        section: 'image',
+        label: 'Coluna do MS',
+        tooltip: 'Nome da coluna no Measurement Set para usar (se aplicável).',
+        type: 'text',
+        defaultValue: 'DATA',
+        category: 'advanced'
+    },
+    {
+        key: 'root_path',
+        section: 'image',
+        label: 'Caminho raiz de saída',
+        tooltip: 'Nome base do arquivo FITS de saída. Sufixo será adicionado automaticamente (_I.fits, etc.).',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true,
+        isFilePath: true
+    }
+]);
+
+/**
+ * Rótulos de seções para o oskar_imager.
+ * @constant {Object<string, string>}
+ */
+const IMAGER_SECTION_LABELS = Object.freeze({
+    image: 'Imagem'
+});
+
+/**
+ * Classe geradora do arquivo .ini do oskar_imager.
+ * Reutiliza a mesma lógica de UI/validação, mas com parâmetros e [General] diferentes.
+ */
+class OskarImagerGenerator {
+    constructor() {
+        /** @type {Object<string, HTMLElement>} */
+        this.inputElements = {};
+
+        this.paramsContainer = document.getElementById('imager-params-container');
+        this.previewTextarea = document.getElementById('imager-preview');
+        this.validationContainer = document.getElementById('imager-validation-messages');
+
+        this._bindButtons();
+        this.renderParameters();
+        this.updatePreview();
+
+        console.log('OskarImagerGenerator inicializado com sucesso.');
+    }
+
+    _bindButtons() {
+        const copyBtn = document.getElementById('imager-copy-btn');
+        const downloadBtn = document.getElementById('imager-download-btn');
+
+        if (copyBtn) copyBtn.addEventListener('click', (e) => { e.preventDefault(); this.copyIni(); });
+        if (downloadBtn) downloadBtn.addEventListener('click', (e) => { e.preventDefault(); this.downloadIni(); });
+    }
+
+    /**
+     * Detecta se o sistema operacional é Windows para usar CRLF.
+     * @private
+     */
+    _getLineEnding() {
+        const isWindows = (typeof navigator !== 'undefined') &&
+            (navigator.platform?.indexOf('Win') >= 0 || /Windows/i.test(navigator.userAgent || ''));
+        return isWindows ? '\r\n' : '\n';
+    }
+
+    /**
+     * Renderiza os inputs de parâmetros agrupados por categoria.
+     */
+    renderParameters() {
+        if (!this.paramsContainer) {
+            console.warn('Container imager-params-container não encontrado no DOM.');
+            return;
+        }
+        this.paramsContainer.innerHTML = '';
+        this.inputElements = {};
+
+        INI_CATEGORIES.forEach(cat => {
+            const params = OSKAR_IMAGER_PARAMS.filter(p => p.category === cat.id);
+            if (params.length === 0) return;
+
+            const catWrapper = document.createElement('div');
+            catWrapper.className = `ini-category ini-category--${cat.id}`;
+
+            const catHeader = document.createElement('div');
+            catHeader.className = 'ini-category__header';
+            catHeader.innerHTML = `<i class="fas ${cat.icon}"></i> <span>${cat.label}</span>`;
+
+            const catBody = document.createElement('div');
+            catBody.className = 'ini-category__body';
+
+            if (cat.collapsible) {
+                catBody.style.display = 'none';
+                const toggleIcon = document.createElement('i');
+                toggleIcon.className = 'fas fa-chevron-down ini-category__toggle';
+                catHeader.appendChild(toggleIcon);
+                catHeader.style.cursor = 'pointer';
+                catHeader.addEventListener('click', () => {
+                    const isHidden = catBody.style.display === 'none';
+                    catBody.style.display = isHidden ? '' : 'none';
+                    toggleIcon.classList.toggle('fa-chevron-down', !isHidden);
+                    toggleIcon.classList.toggle('fa-chevron-up', isHidden);
+                });
+            }
+
+            // Agrupa por seção
+            const grouped = {};
+            params.forEach(p => {
+                if (!grouped[p.section]) grouped[p.section] = [];
+                grouped[p.section].push(p);
+            });
+
+            ['image'].forEach(sec => {
+                if (!grouped[sec]) return;
+                const sectionDiv = document.createElement('fieldset');
+                sectionDiv.className = 'ini-section';
+                const legend = document.createElement('legend');
+                legend.textContent = IMAGER_SECTION_LABELS[sec] || sec;
+                sectionDiv.appendChild(legend);
+
+                grouped[sec].forEach(param => {
+                    sectionDiv.appendChild(this._createParamRow(param));
+                });
+
+                catBody.appendChild(sectionDiv);
+            });
+
+            catWrapper.appendChild(catHeader);
+            catWrapper.appendChild(catBody);
+            this.paramsContainer.appendChild(catWrapper);
+        });
+    }
+
+    /**
+     * Cria a linha de input para um parâmetro (reutiliza lógica do interferometer).
+     * @private
+     */
+    _createParamRow(param) {
+        const row = document.createElement('div');
+        row.className = 'ini-param-row';
+        if (param.required) row.classList.add('ini-param-row--required');
+
+        const label = document.createElement('label');
+        const inputId = `imager-input-${param.section}-${param.key.replace(/[/.]/g, '_')}`;
+        label.setAttribute('for', inputId);
+        label.textContent = param.label;
+        if (param.required) {
+            const req = document.createElement('span');
+            req.className = 'ini-required-mark';
+            req.textContent = ' *';
+            label.appendChild(req);
+        }
+
+        const tooltipIcon = document.createElement('i');
+        tooltipIcon.className = 'fas fa-question-circle ini-tooltip-icon';
+        tooltipIcon.title = param.tooltip;
+        label.appendChild(tooltipIcon);
+
+        let input;
+        if (param.type === 'select' && param.options) {
+            input = document.createElement('select');
+            param.options.forEach(opt => {
+                const option = document.createElement('option');
+                option.value = opt.value;
+                option.textContent = opt.label;
+                if (String(opt.value) === String(param.defaultValue)) option.selected = true;
+                input.appendChild(option);
+            });
+        } else if (param.type === 'checkbox') {
+            input = document.createElement('input');
+            input.type = 'checkbox';
+            input.checked = !!param.defaultValue;
+        } else {
+            input = document.createElement('input');
+            input.type = param.type === 'number' ? 'number' : 'text';
+            if (param.type === 'number') input.step = 'any';
+            input.value = param.defaultValue !== undefined ? param.defaultValue : '';
+        }
+
+        input.id = inputId;
+        input.className = 'ini-param-input';
+        input.dataset.iniKey = param.key;
+        input.dataset.iniSection = param.section;
+
+        input.addEventListener('change', () => this.updatePreview());
+        input.addEventListener('input', () => this.updatePreview());
+
+        const errorSpan = document.createElement('span');
+        errorSpan.className = 'ini-field-error';
+
+        const compositeKey = `${param.section}.${param.key}`;
+        this.inputElements[compositeKey] = input;
+
+        row.appendChild(label);
+
+        if (param.isFilePath) {
+            const inputWrapper = document.createElement('div');
+            inputWrapper.className = 'ini-file-input-wrapper';
+            inputWrapper.appendChild(input);
+
+            const browseBtn = document.createElement('button');
+            browseBtn.type = 'button';
+            browseBtn.className = 'ini-browse-btn';
+            browseBtn.title = 'Selecionar arquivo do computador';
+            browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
+
+            const hiddenFileInput = document.createElement('input');
+            hiddenFileInput.type = 'file';
+            hiddenFileInput.style.display = 'none';
+            if (param.fileAccept) hiddenFileInput.accept = param.fileAccept;
+
+            browseBtn.addEventListener('click', (e) => {
+                e.preventDefault();
+                hiddenFileInput.click();
+            });
+
+            hiddenFileInput.addEventListener('change', (ev) => {
+                if (ev.target.files && ev.target.files.length > 0) {
+                    const file = ev.target.files[0];
+                    input.value = file.webkitRelativePath || file.name;
+                    input.dispatchEvent(new Event('input'));
+                }
+            });
+
+            inputWrapper.appendChild(browseBtn);
+            inputWrapper.appendChild(hiddenFileInput);
+            row.appendChild(inputWrapper);
+        } else {
+            row.appendChild(input);
+        }
+
+        row.appendChild(errorSpan);
+        return row;
+    }
+
+    /**
+     * Gera o conteúdo do arquivo .ini do imager.
+     */
+    generateIni() {
+        const eol = this._getLineEnding();
+        const sections = {};
+
+        OSKAR_IMAGER_PARAMS.forEach(param => {
+            const compositeKey = `${param.section}.${param.key}`;
+            const input = this.inputElements[compositeKey];
+            if (!input) return;
+
+            let value;
+            if (param.type === 'checkbox') {
+                value = input.checked ? 'true' : 'false';
+            } else {
+                value = input.value;
+            }
+
+            if (value === '' && !param.required) return;
+
+            if (!sections[param.section]) sections[param.section] = [];
+            sections[param.section].push({ key: param.key, value });
+        });
+
+        const lines = [];
+        lines.push('[General]');
+        lines.push('app=oskar_imager');
+        lines.push('');
+
+        ['image'].forEach(sec => {
+            if (!sections[sec] || sections[sec].length === 0) return;
+            lines.push(`[${sec}]`);
+            sections[sec].forEach(entry => {
+                lines.push(`${entry.key}=${entry.value}`);
+            });
+            lines.push('');
+        });
+
+        return lines.join(eol);
+    }
+
+    updatePreview() {
+        if (!this.previewTextarea) return;
+        this.previewTextarea.value = this.generateIni();
+    }
+
+    validateFields() {
+        let allValid = true;
+        OSKAR_IMAGER_PARAMS.forEach(param => {
+            const compositeKey = `${param.section}.${param.key}`;
+            const input = this.inputElements[compositeKey];
+            if (!input) return;
+
+            const row = input.closest('.ini-param-row');
+            const errorSpan = row ? row.querySelector('.ini-field-error') : null;
+            let errorMsg = '';
+
+            const value = (param.type === 'checkbox') ? input.checked : input.value;
+            if (param.required && (value === '' || value === null || value === undefined)) {
+                errorMsg = 'Campo obrigatório.';
+            }
+            if (!errorMsg && param.type === 'number' && value !== '') {
+                if (isNaN(Number(value))) errorMsg = 'Valor numérico inválido.';
+            }
+
+            if (errorMsg) {
+                allValid = false;
+                if (input.classList) input.classList.add('ini-input--error');
+            } else {
+                if (input.classList) input.classList.remove('ini-input--error');
+            }
+            if (errorSpan) errorSpan.textContent = errorMsg;
+        });
+
+        if (this.validationContainer) {
+            this.validationContainer.innerHTML = allValid
+                ? '<span class="ini-validation-ok"><i class="fas fa-check-circle"></i> Todos os campos estão válidos.</span>'
+                : '<span class="ini-validation-error"><i class="fas fa-exclamation-triangle"></i> Campos com erros.</span>';
+        }
+        return allValid;
+    }
+
+    downloadIni() {
+        if (!this.validateFields()) {
+            console.warn('Download cancelado: campos com erro.');
+            return;
+        }
+        const content = this.generateIni();
+        const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = 'oskar_imager.ini';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        console.log('Arquivo oskar_imager.ini baixado com sucesso.');
+    }
+
+    copyIni() {
+        const content = this.generateIni();
+        const copyBtn = document.getElementById('imager-copy-btn');
+
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+            navigator.clipboard.writeText(content).then(() => {
+                this._showCopyFeedback(copyBtn, true);
+            }).catch(() => {
+                this._showCopyFeedback(copyBtn, false);
+            });
+        } else if (this.previewTextarea) {
+            this.previewTextarea.select();
+            document.execCommand('copy');
+            this._showCopyFeedback(copyBtn, true);
+        }
+    }
+
+    _showCopyFeedback(button, success) {
+        if (!button) return;
+        const icon = button.querySelector('i');
+        if (!icon) return;
+        const orig = 'fa-copy';
+        const feedback = success ? 'fa-check' : 'fa-times';
+        icon.classList.remove(orig);
+        icon.classList.add(feedback);
+        button.style.color = success ? 'var(--success-color)' : 'var(--secondary-color)';
+        setTimeout(() => {
+            icon.classList.remove(feedback);
+            icon.classList.add(orig);
+            button.style.color = '';
+        }, 1500);
+    }
+}
+
+// =============================================================================
+// Inicialização
+// =============================================================================
+
+document.addEventListener('DOMContentLoaded', () => {
+    if (!window.oskarIniGenerator) {
+        try {
+            window.oskarIniGenerator = new OskarIniGenerator();
+            console.log('Instância de OskarIniGenerator criada e configurada.');
+        } catch (error) {
+            console.error('Erro ao instanciar OskarIniGenerator:', error);
+        }
+    } else {
+        window.oskarIniGenerator.updatePreview();
+    }
+
+    if (!window.oskarImagerGenerator) {
+        try {
+            window.oskarImagerGenerator = new OskarImagerGenerator();
+            console.log('Instância de OskarImagerGenerator criada e configurada.');
+        } catch (error) {
+            console.error('Erro ao instanciar OskarImagerGenerator:', error);
+        }
+    } else {
+        window.oskarImagerGenerator.updatePreview();
     }
 });

From 12d104b537890d017bf0f100d0c8e1c0debafc06 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 00:06:48 +0000
Subject: [PATCH 16/22] Address code review: extract shared getOsLineEnding
 utility, use userAgentData, fix comment

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/ini_generator.js | 44 +++++++++++++++++++-------------------------
 1 file changed, 19 insertions(+), 25 deletions(-)

diff --git a/js/ini_generator.js b/js/ini_generator.js
index e740f9a..65e2345 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -19,6 +19,20 @@ const INI_BINGO_LATITUDE = (typeof BingoConstants !== 'undefined') ? BingoConsta
 const INI_BINGO_LONGITUDE = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_LONGITUDE : -38.26884;
 const INI_BINGO_ALTITUDE = (typeof BingoConstants !== 'undefined') ? BingoConstants.BINGO_ALTITUDE : 396.4;
 
+/**
+ * Detecta a quebra de linha adequada para o SO do usuário.
+ * Windows usa CRLF (\r\n), Linux/Mac usam LF (\n). Sempre UTF-8.
+ * @returns {string} '\r\n' para Windows, '\n' para outros.
+ */
+function getOsLineEnding() {
+    if (typeof navigator === 'undefined') return '\n';
+    // Prefere navigator.userAgentData.platform (moderno) com fallback
+    const platform = navigator.userAgentData?.platform || navigator.platform || '';
+    if (/Win/i.test(platform)) return '\r\n';
+    if (/Windows/i.test(navigator.userAgent || '')) return '\r\n';
+    return '\n';
+}
+
 /**
  * Definição dos parâmetros OSKAR suportados pelo gerador.
  * Cada entrada descreve um parâmetro de configuração do .ini.
@@ -992,8 +1006,9 @@ class OskarIniGenerator {
                 : 'Selecionar arquivo do computador';
             browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
 
-            // Para diretórios, usa um input de arquivo regular (sem webkitdirectory)
-            // para evitar popup de confirmação do navegador e obter caminho completo
+            // Usa input de arquivo regular (sem webkitdirectory) para evitar popup
+            // de confirmação do navegador. O caminho completo é limitado por segurança
+            // do navegador — o campo é editável para que o usuário cole o caminho real.
             const hiddenFileInput = document.createElement('input');
             hiddenFileInput.type = 'file';
             hiddenFileInput.style.display = 'none';
@@ -1036,23 +1051,12 @@ class OskarIniGenerator {
     // Geração do conteúdo INI
     // =========================================================================
 
-    /**
-     * Detecta se o sistema operacional é Windows para usar CRLF.
-     * @private
-     * @returns {string} Quebra de linha adequada ('\r\n' para Windows, '\n' para outros).
-     */
-    _getLineEnding() {
-        const isWindows = (typeof navigator !== 'undefined') &&
-            (navigator.platform?.indexOf('Win') >= 0 || /Windows/i.test(navigator.userAgent || ''));
-        return isWindows ? '\r\n' : '\n';
-    }
-
     /**
      * Gera o conteúdo completo do arquivo .ini a partir dos valores atuais.
      * @returns {string} Conteúdo formatado do arquivo .ini.
      */
     generateIni() {
-        const eol = this._getLineEnding();
+        const eol = getOsLineEnding();
         const sections = {};
 
         OSKAR_INI_PARAMS.forEach(param => {
@@ -1833,16 +1837,6 @@ class OskarImagerGenerator {
         if (downloadBtn) downloadBtn.addEventListener('click', (e) => { e.preventDefault(); this.downloadIni(); });
     }
 
-    /**
-     * Detecta se o sistema operacional é Windows para usar CRLF.
-     * @private
-     */
-    _getLineEnding() {
-        const isWindows = (typeof navigator !== 'undefined') &&
-            (navigator.platform?.indexOf('Win') >= 0 || /Windows/i.test(navigator.userAgent || ''));
-        return isWindows ? '\r\n' : '\n';
-    }
-
     /**
      * Renderiza os inputs de parâmetros agrupados por categoria.
      */
@@ -2016,7 +2010,7 @@ class OskarImagerGenerator {
      * Gera o conteúdo do arquivo .ini do imager.
      */
     generateIni() {
-        const eol = this._getLineEnding();
+        const eol = getOsLineEnding();
         const sections = {};
 
         OSKAR_IMAGER_PARAMS.forEach(param => {

From a7ad3e48b134769de3c72ebe5ad9aaebba9c3878 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 00:24:39 +0000
Subject: [PATCH 17/22] Fix imager preview height, file path selector (prompt),
 imager-interferometer link, add beam pattern INI

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css      |    4 +-
 index.html          |   27 +
 js/ini_generator.js | 1287 ++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 1253 insertions(+), 65 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index 7daced4..4aa563d 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -1136,7 +1136,9 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
 .ini-collapsible-content.expanded {
     display: block;
 }
-#ini-preview {
+#ini-preview,
+#imager-preview,
+#beam-pattern-ini-preview {
     flex: 1;
     min-height: 400px;
     padding: 12px;
diff --git a/index.html b/index.html
index d4a409f..375a9a3 100644
--- a/index.html
+++ b/index.html
@@ -504,6 +504,11 @@ <h2><i class="fas fa-image"></i> Gerador de Arquivo do Imager (.ini)</h2>
                 <p class="section-description">Monte o arquivo <code>.ini</code> de configuração do <strong>oskar_imager</strong>. Configura a geração de imagens a partir dos dados de visibilidade simulados.</p>
                 <div class="ini-layout">
                     <div class="ini-params-area">
+                        <div class="ini-toolbar">
+                            <button id="imager-use-interf-output-btn" class="secondary small-btn" title="Usa o mesmo caminho do arquivo .vis definido no bloco do interferômetro como entrada para o imager.">
+                                <i class="fas fa-link"></i> Usar saída do Interferômetro
+                            </button>
+                        </div>
                         <div id="imager-params-container" class="ini-params-container">
                             <p class="placeholder-text">Carregando parâmetros do imager...</p>
                         </div>
@@ -519,6 +524,28 @@ <h3>Preview do arquivo oskar_imager.ini</h3>
                     </div>
                 </div>
             </section>
+
+            <!-- === BLOCO 3: OSKAR SIM BEAM PATTERN (.ini) === -->
+            <section class="ini-generator-section" style="margin-top: 30px;">
+                <h2><i class="fas fa-satellite-dish"></i> Gerador de Arquivo do Beam Pattern (.ini)</h2>
+                <p class="section-description">Monte o arquivo <code>.ini</code> de configuração do <strong>oskar_sim_beam_pattern</strong>. Simula o padrão de feixe (beam pattern) de stations do telescópio.</p>
+                <div class="ini-layout">
+                    <div class="ini-params-area">
+                        <div id="beam-pattern-ini-params-container" class="ini-params-container">
+                            <p class="placeholder-text">Carregando parâmetros do beam pattern...</p>
+                        </div>
+                        <div id="beam-pattern-ini-validation-messages" class="validation-messages"></div>
+                    </div>
+                    <div class="ini-preview-area">
+                        <h3>Preview do arquivo oskar_sim_beam_pattern.ini</h3>
+                        <textarea id="beam-pattern-ini-preview" readonly placeholder="O conteúdo do arquivo .ini do beam pattern aparecerá aqui..."></textarea>
+                        <div class="ini-actions">
+                            <button id="beam-pattern-ini-copy-btn" class="secondary small-btn"><i class="fas fa-copy"></i> Copiar</button>
+                            <button id="beam-pattern-ini-download-btn" class="primary small-btn"><i class="fas fa-download"></i> Baixar oskar_sim_beam_pattern.ini</button>
+                        </div>
+                    </div>
+                </div>
+            </section>
         </div><!-- Fim #tab-oskar-config -->
 
         <!-- === ABA 3: MODELO DE CÉU === -->
diff --git a/js/ini_generator.js b/js/ini_generator.js
index 65e2345..ab71160 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -992,52 +992,38 @@ class OskarIniGenerator {
 
         row.appendChild(label);
 
-        // Para campos de arquivo/diretório, cria um wrapper com botão de browse
+        // Para campos de arquivo/diretório, cria um wrapper com botão para digitar caminho
         if (param.isFilePath) {
             const inputWrapper = document.createElement('div');
             inputWrapper.className = 'ini-file-input-wrapper';
+            input.placeholder = param.isDirectory
+                ? 'Ex: /home/user/telescope'
+                : 'Ex: /home/user/data/output.vis';
             inputWrapper.appendChild(input);
 
             const browseBtn = document.createElement('button');
             browseBtn.type = 'button';
             browseBtn.className = 'ini-browse-btn';
-            browseBtn.title = param.isDirectory
-                ? 'Selecionar pasta do computador'
-                : 'Selecionar arquivo do computador';
+            browseBtn.title = 'Inserir caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
             browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
 
-            // Usa input de arquivo regular (sem webkitdirectory) para evitar popup
-            // de confirmação do navegador. O caminho completo é limitado por segurança
-            // do navegador — o campo é editável para que o usuário cole o caminho real.
-            const hiddenFileInput = document.createElement('input');
-            hiddenFileInput.type = 'file';
-            hiddenFileInput.style.display = 'none';
-            if (param.fileAccept) {
-                hiddenFileInput.accept = param.fileAccept;
-            }
-
+            // Navegadores não permitem acesso ao caminho completo por segurança.
+            // Abre um prompt para o usuário colar o caminho completo do seu sistema.
             browseBtn.addEventListener('click', (e) => {
                 e.preventDefault();
-                hiddenFileInput.click();
-            });
-
-            hiddenFileInput.addEventListener('change', (ev) => {
-                if (ev.target.files && ev.target.files.length > 0) {
-                    const file = ev.target.files[0];
-                    // Tenta extrair o caminho completo via webkitRelativePath
-                    // Navegadores limitam acesso ao caminho completo por segurança
-                    // Usamos o nome do arquivo e o caminho relativo quando disponível
-                    let filePath = file.name;
-                    if (file.webkitRelativePath) {
-                        filePath = file.webkitRelativePath;
-                    }
-                    input.value = filePath;
+                const label = param.isDirectory ? 'diretório' : 'arquivo';
+                const currentVal = input.value || '';
+                const path = prompt(
+                    `Cole o caminho completo do ${label} no seu computador:`,
+                    currentVal
+                );
+                if (path !== null && path.trim() !== '') {
+                    input.value = path.trim();
                     input.dispatchEvent(new Event('input'));
                 }
             });
 
             inputWrapper.appendChild(browseBtn);
-            inputWrapper.appendChild(hiddenFileInput);
             row.appendChild(inputWrapper);
         } else {
             row.appendChild(input);
@@ -1832,9 +1818,32 @@ class OskarImagerGenerator {
     _bindButtons() {
         const copyBtn = document.getElementById('imager-copy-btn');
         const downloadBtn = document.getElementById('imager-download-btn');
+        const useInterfBtn = document.getElementById('imager-use-interf-output-btn');
 
         if (copyBtn) copyBtn.addEventListener('click', (e) => { e.preventDefault(); this.copyIni(); });
         if (downloadBtn) downloadBtn.addEventListener('click', (e) => { e.preventDefault(); this.downloadIni(); });
+        if (useInterfBtn) useInterfBtn.addEventListener('click', (e) => { e.preventDefault(); this.useInterferometerOutput(); });
+    }
+
+    /**
+     * Preenche o campo de entrada de visibilidades com o caminho de saída do interferômetro.
+     */
+    useInterferometerOutput() {
+        const visInput = this.inputElements['image.input_vis_data'];
+        if (!visInput) return;
+
+        // Tenta obter o caminho de saída definido no interferômetro
+        let visPath = '';
+        if (window.oskarIniGenerator && window.oskarIniGenerator.inputElements['interferometer.oskar_vis_filename']) {
+            visPath = window.oskarIniGenerator.inputElements['interferometer.oskar_vis_filename'].value || '';
+        }
+        if (!visPath) {
+            alert('Nenhum caminho de saída .vis foi definido no bloco do interferômetro. Defina-o primeiro.');
+            return;
+        }
+        visInput.value = visPath;
+        visInput.dispatchEvent(new Event('input'));
+        console.log('Campo de entrada do imager preenchido com saída do interferômetro:', visPath);
     }
 
     /**
@@ -1969,34 +1978,32 @@ class OskarImagerGenerator {
         if (param.isFilePath) {
             const inputWrapper = document.createElement('div');
             inputWrapper.className = 'ini-file-input-wrapper';
+            input.placeholder = param.isDirectory
+                ? 'Ex: /home/user/telescope'
+                : 'Ex: /home/user/data/output.vis';
             inputWrapper.appendChild(input);
 
             const browseBtn = document.createElement('button');
             browseBtn.type = 'button';
             browseBtn.className = 'ini-browse-btn';
-            browseBtn.title = 'Selecionar arquivo do computador';
+            browseBtn.title = 'Inserir caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
             browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
 
-            const hiddenFileInput = document.createElement('input');
-            hiddenFileInput.type = 'file';
-            hiddenFileInput.style.display = 'none';
-            if (param.fileAccept) hiddenFileInput.accept = param.fileAccept;
-
             browseBtn.addEventListener('click', (e) => {
                 e.preventDefault();
-                hiddenFileInput.click();
-            });
-
-            hiddenFileInput.addEventListener('change', (ev) => {
-                if (ev.target.files && ev.target.files.length > 0) {
-                    const file = ev.target.files[0];
-                    input.value = file.webkitRelativePath || file.name;
+                const label = param.isDirectory ? 'diretório' : 'arquivo';
+                const currentVal = input.value || '';
+                const path = prompt(
+                    `Cole o caminho completo do ${label} no seu computador:`,
+                    currentVal
+                );
+                if (path !== null && path.trim() !== '') {
+                    input.value = path.trim();
                     input.dispatchEvent(new Event('input'));
                 }
             });
 
             inputWrapper.appendChild(browseBtn);
-            inputWrapper.appendChild(hiddenFileInput);
             row.appendChild(inputWrapper);
         } else {
             row.appendChild(input);
@@ -2142,29 +2149,1181 @@ class OskarImagerGenerator {
 }
 
 // =============================================================================
-// Inicialização
+// OSKAR Sim Beam Pattern - Parâmetros e Gerador
 // =============================================================================
 
-document.addEventListener('DOMContentLoaded', () => {
-    if (!window.oskarIniGenerator) {
-        try {
-            window.oskarIniGenerator = new OskarIniGenerator();
-            console.log('Instância de OskarIniGenerator criada e configurada.');
-        } catch (error) {
-            console.error('Erro ao instanciar OskarIniGenerator:', error);
-        }
-    } else {
-        window.oskarIniGenerator.updatePreview();
-    }
+/**
+ * Definição dos parâmetros do oskar_sim_beam_pattern.
+ * @constant {Array<Object>}
+ */
+const OSKAR_BEAM_PATTERN_PARAMS = Object.freeze([
+    // =========================================================================
+    // [simulator]
+    // =========================================================================
+    {
+        key: 'double_precision',
+        section: 'simulator',
+        label: 'Precisão dupla',
+        tooltip: 'Ativa cálculos em precisão dupla (64 bits). Mais exato, porém mais lento na GPU.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim (mais preciso)' },
+            { value: 'false', label: 'Não (mais rápido)' }
+        ]
+    },
+    {
+        key: 'use_gpus',
+        section: 'simulator',
+        label: 'Usar GPUs',
+        tooltip: 'Se habilitado, usa dispositivos GPU disponíveis para a simulação.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'cuda_device_ids',
+        section: 'simulator',
+        label: 'IDs de dispositivos CUDA',
+        tooltip: 'Lista separada por vírgulas de IDs de GPUs, ou "all" para usar todos os dispositivos.',
+        type: 'text',
+        defaultValue: 'all',
+        category: 'advanced'
+    },
+    {
+        key: 'num_devices',
+        section: 'simulator',
+        label: 'Número de dispositivos',
+        tooltip: 'Número de dispositivos de computação. "auto" usa todos disponíveis. Não ultrapasse o número de cores da CPU.',
+        type: 'text',
+        defaultValue: 'auto',
+        category: 'advanced'
+    },
+    {
+        key: 'max_sources_per_chunk',
+        section: 'simulator',
+        label: 'Máx. fontes por chunk',
+        tooltip: 'Número máximo de fontes/pixels processados por vez em cada dispositivo. Reduza se a GPU ficar sem memória.',
+        type: 'number',
+        defaultValue: 16384,
+        category: 'advanced'
+    },
+    {
+        key: 'keep_log_file',
+        section: 'simulator',
+        label: 'Manter arquivo de log',
+        tooltip: 'Se habilitado, mantém o arquivo de log em disco após a simulação.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'write_status_to_log_file',
+        section: 'simulator',
+        label: 'Gravar status no log',
+        tooltip: 'Se habilitado, mensagens de progresso são gravadas no arquivo de log.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
 
-    if (!window.oskarImagerGenerator) {
-        try {
-            window.oskarImagerGenerator = new OskarImagerGenerator();
-            console.log('Instância de OskarImagerGenerator criada e configurada.');
-        } catch (error) {
-            console.error('Erro ao instanciar OskarImagerGenerator:', error);
-        }
-    } else {
-        window.oskarImagerGenerator.updatePreview();
+    // =========================================================================
+    // [observation]
+    // =========================================================================
+    {
+        key: 'mode',
+        section: 'observation',
+        label: 'Modo de observação',
+        tooltip: 'Modo: Tracking (acompanhamento) ou Drift Scan (varredura por deriva).',
+        type: 'select',
+        defaultValue: 'Tracking',
+        category: 'essential',
+        options: [
+            { value: 'Tracking', label: 'Tracking' },
+            { value: 'Drift Scan', label: 'Drift Scan' }
+        ]
+    },
+    {
+        key: 'phase_centre_ra_deg',
+        section: 'observation',
+        label: 'Ascensão Reta do centro de fase (°)',
+        tooltip: 'Ascensão Reta do apontamento (centro de fase), em graus.',
+        type: 'number',
+        defaultValue: 0,
+        category: 'essential'
+    },
+    {
+        key: 'phase_centre_dec_deg',
+        section: 'observation',
+        label: 'Declinação do centro de fase (°)',
+        tooltip: 'Declinação do apontamento (centro de fase), em graus.',
+        type: 'number',
+        defaultValue: 0,
+        category: 'essential'
+    },
+    {
+        key: 'pointing_file',
+        section: 'observation',
+        label: 'Arquivo de apontamento',
+        tooltip: 'Caminho para arquivo opcional de apontamento de stations, que pode sobrescrever a direção do feixe.',
+        type: 'text',
+        defaultValue: '',
+        category: 'advanced',
+        isFilePath: true
+    },
+    {
+        key: 'start_frequency_hz',
+        section: 'observation',
+        label: 'Frequência inicial (Hz)',
+        tooltip: 'Frequência no ponto médio do primeiro canal, em Hz.',
+        type: 'number',
+        defaultValue: '',
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'num_channels',
+        section: 'observation',
+        label: 'Número de canais',
+        tooltip: 'Número de canais de frequência a utilizar.',
+        type: 'number',
+        defaultValue: 1,
+        category: 'essential'
+    },
+    {
+        key: 'frequency_inc_hz',
+        section: 'observation',
+        label: 'Incremento de frequência (Hz)',
+        tooltip: 'Incremento de frequência entre canais sucessivos, em Hz.',
+        type: 'number',
+        defaultValue: 0,
+        category: 'recommended'
+    },
+    {
+        key: 'start_time_utc',
+        section: 'observation',
+        label: 'Hora de início (UTC)',
+        tooltip: 'Data/hora de início da observação. Pode ser MJD ou formato: yyyy-M-d h:m:s.z',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'length',
+        section: 'observation',
+        label: 'Duração da observação',
+        tooltip: 'Duração em segundos, ou no formato h:m:s.z',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true
+    },
+    {
+        key: 'num_time_steps',
+        section: 'observation',
+        label: 'Número de passos de tempo',
+        tooltip: 'Número de snapshots do beam pattern durante a observação.',
+        type: 'number',
+        defaultValue: 1,
+        category: 'essential'
+    },
+
+    // =========================================================================
+    // [telescope]
+    // =========================================================================
+    {
+        key: 'input_directory',
+        section: 'telescope',
+        label: 'Diretório do telescópio',
+        tooltip: 'Caminho para o diretório com os dados de configuração do telescópio OSKAR.',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true,
+        isFilePath: true,
+        isDirectory: true
+    },
+    {
+        key: 'normalise_beams_at_phase_centre',
+        section: 'telescope',
+        label: 'Normalizar feixes no centro de fase',
+        tooltip: 'Se true, escala a amplitude de cada station beam no centro de fase para 1.0 em cada snapshot.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'allow_station_beam_duplication',
+        section: 'telescope',
+        label: 'Permitir duplicação de beams',
+        tooltip: 'Se habilitado, duplica beams de configurações de stations comuns. Reduz tempo mas pode causar erros com baselines longas.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'pol_mode',
+        section: 'telescope',
+        label: 'Modo de polarização',
+        tooltip: 'Full: simula ambas polarizações. Scalar: apenas Stokes I (mais rápido).',
+        type: 'select',
+        defaultValue: 'Full',
+        category: 'recommended',
+        options: [
+            { value: 'Full', label: 'Full (completo)' },
+            { value: 'Scalar', label: 'Scalar (apenas Stokes I)' }
+        ]
+    },
+    {
+        key: 'station_type',
+        section: 'telescope',
+        label: 'Tipo de station',
+        tooltip: 'Tipo de cada station: Aperture Array (padrão), Gaussian beam (teste), ou Isotropic (sem efeito de beam).',
+        type: 'select',
+        defaultValue: 'A',
+        category: 'recommended',
+        options: [
+            { value: 'A', label: 'Aperture Array (A)' },
+            { value: 'G', label: 'Gaussian Beam (G)' },
+            { value: 'I', label: 'Isotropic Beam (I)' }
+        ]
+    },
+    {
+        key: 'aperture_array/array_pattern/enable',
+        section: 'telescope',
+        label: 'Habilitar array pattern',
+        tooltip: 'Se true, avalia a contribuição do array pattern (beamforming das antenas) no beam da station.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'aperture_array/array_pattern/normalise',
+        section: 'telescope',
+        label: 'Normalizar array pattern',
+        tooltip: 'Se true, divide a amplitude do station beam pelo número de antenas na station.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/enable_numerical',
+        section: 'telescope',
+        label: 'Habilitar padrão numérico de elemento',
+        tooltip: 'Se true, usa arquivos de padrão numérico quando disponíveis. Caso contrário, usa o tipo funcional.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'advanced',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/functional_type',
+        section: 'telescope',
+        label: 'Tipo funcional do elemento',
+        tooltip: 'Tipo de padrão funcional aplicado aos elementos (se não usando padrão numérico).',
+        type: 'select',
+        defaultValue: 'Dipole',
+        category: 'advanced',
+        options: [
+            { value: 'Dipole', label: 'Dipolo' },
+            { value: 'Geometric dipole', label: 'Dipolo geométrico' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/dipole_length',
+        section: 'telescope',
+        label: 'Comprimento do dipolo',
+        tooltip: 'Comprimento do dipolo (valor padrão 0.5 comprimentos de onda).',
+        type: 'number',
+        defaultValue: 0.5,
+        category: 'advanced'
+    },
+    {
+        key: 'aperture_array/element_pattern/dipole_length_units',
+        section: 'telescope',
+        label: 'Unidades do comprimento do dipolo',
+        tooltip: 'Unidades para o comprimento do dipolo: metros ou comprimentos de onda.',
+        type: 'select',
+        defaultValue: 'Wavelengths',
+        category: 'advanced',
+        options: [
+            { value: 'Wavelengths', label: 'Comprimentos de onda' },
+            { value: 'Metres', label: 'Metros' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/taper/type',
+        section: 'telescope',
+        label: 'Tipo de tapering do elemento',
+        tooltip: 'Tipo de função de tapering aplicada ao padrão do elemento.',
+        type: 'select',
+        defaultValue: 'None',
+        category: 'advanced',
+        options: [
+            { value: 'None', label: 'Nenhum' },
+            { value: 'Cosine', label: 'Cosseno' },
+            { value: 'Gaussian', label: 'Gaussiana' }
+        ]
+    },
+    {
+        key: 'aperture_array/element_pattern/taper/cosine_power',
+        section: 'telescope',
+        label: 'Potência do taper cosseno',
+        tooltip: 'Potência da função cos(θ) se tapering tipo cosseno estiver selecionado.',
+        type: 'number',
+        defaultValue: 1.0,
+        category: 'advanced'
+    },
+    {
+        key: 'aperture_array/element_pattern/taper/gaussian_fwhm_deg',
+        section: 'telescope',
+        label: 'FWHM do taper gaussiano (°)',
+        tooltip: 'Largura a meia altura (FWHM) do tapering gaussiano, em graus.',
+        type: 'number',
+        defaultValue: 45.0,
+        category: 'advanced'
+    },
+    {
+        key: 'gaussian_beam/fwhm_deg',
+        section: 'telescope',
+        label: 'FWHM do Gaussian beam (°)',
+        tooltip: 'Para stations com beam gaussiano simples: FWHM na frequência de referência, em graus.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'gaussian_beam/ref_freq_hz',
+        section: 'telescope',
+        label: 'Freq. de referência do Gaussian beam (Hz)',
+        tooltip: 'Frequência de referência do FWHM especificado, em Hz.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'ionosphere_screen_type',
+        section: 'telescope',
+        label: 'Tipo de tela ionosférica',
+        tooltip: 'Tipo de phase screen ionosférica a utilizar.',
+        type: 'select',
+        defaultValue: 'None',
+        category: 'advanced',
+        options: [
+            { value: 'None', label: 'Nenhum' },
+            { value: 'External', label: 'Externo (FITS)' }
+        ]
+    },
+    {
+        key: 'external_tec_screen/input_fits_file',
+        section: 'telescope',
+        label: 'Arquivo FITS da tela TEC',
+        tooltip: 'Caminho para arquivo FITS (ARatmospy) para a tela TEC.',
+        type: 'text',
+        defaultValue: '',
+        category: 'advanced',
+        isFilePath: true
+    },
+    {
+        key: 'external_tec_screen/screen_height_km',
+        section: 'telescope',
+        label: 'Altura da tela ionosférica (km)',
+        tooltip: 'Altura da tela ionosférica, em quilômetros.',
+        type: 'number',
+        defaultValue: 300,
+        category: 'advanced'
+    },
+
+    // =========================================================================
+    // [beam_pattern]
+    // =========================================================================
+    {
+        key: 'all_stations',
+        section: 'beam_pattern',
+        label: 'Todas as stations',
+        tooltip: 'Se habilitado, produz beams para todas as stations do modelo de telescópio.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'essential',
+        options: [
+            { value: 'true', label: 'Sim (todas)' },
+            { value: 'false', label: 'Não (selecionadas)' }
+        ]
+    },
+    {
+        key: 'station_ids',
+        section: 'beam_pattern',
+        label: 'IDs de stations',
+        tooltip: 'IDs (base-zero) das stations para gerar beam patterns. Separados por vírgula (CSV).',
+        type: 'text',
+        defaultValue: '0',
+        category: 'essential'
+    },
+    {
+        key: 'coordinate_frame',
+        section: 'beam_pattern',
+        label: 'Sistema de coordenadas',
+        tooltip: 'Sistema de coordenadas para avaliar o beam pattern. Horizon cobre o céu inteiro.',
+        type: 'select',
+        defaultValue: 'Equatorial',
+        category: 'recommended',
+        options: [
+            { value: 'Equatorial', label: 'Equatorial' },
+            { value: 'Horizon', label: 'Horizon' }
+        ]
+    },
+    {
+        key: 'coordinate_type',
+        section: 'beam_pattern',
+        label: 'Tipo de coordenadas',
+        tooltip: 'Beam image: imagem no plano tangente centrada no phase centre. Sky model: avalia apenas nas coordenadas fornecidas.',
+        type: 'select',
+        defaultValue: 'Beam image',
+        category: 'recommended',
+        options: [
+            { value: 'Beam image', label: 'Beam image (plano tangente)' },
+            { value: 'Sky model', label: 'Sky model (coordenadas fornecidas)' }
+        ]
+    },
+    {
+        key: 'beam_image/specify_cellsize',
+        section: 'beam_pattern',
+        label: 'Especificar cellsize',
+        tooltip: 'Se habilitado, especifica cellsize; caso contrário, especifica campo de visão (FOV).',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim (cellsize)' },
+            { value: 'false', label: 'Não (FOV)' }
+        ]
+    },
+    {
+        key: 'beam_image/size',
+        section: 'beam_pattern',
+        label: 'Dimensões da imagem (px)',
+        tooltip: 'Dimensões da imagem. Valor único = quadrado (ex: 256 → 256×256). Pode ser "256,128" para largura×altura.',
+        type: 'text',
+        defaultValue: '256',
+        category: 'essential'
+    },
+    {
+        key: 'beam_image/fov_deg',
+        section: 'beam_pattern',
+        label: 'Campo de visão (°)',
+        tooltip: 'FOV total em graus (máx 180). Valor único = igual em ambas dimensões. Pode ser "2.0,1.0".',
+        type: 'text',
+        defaultValue: '2.0',
+        category: 'essential'
+    },
+    {
+        key: 'beam_image/cellsize_arcsec',
+        section: 'beam_pattern',
+        label: 'Cellsize (arcsec)',
+        tooltip: 'Tamanho do pixel em arco-segundos (usado se "Especificar cellsize" = Sim).',
+        type: 'number',
+        defaultValue: 1.0,
+        category: 'recommended'
+    },
+    {
+        key: 'sky_model/file',
+        section: 'beam_pattern',
+        label: 'Arquivo do modelo de céu',
+        tooltip: 'Caminho para arquivo de sky model de entrada (para avaliar beam em coordenadas específicas).',
+        type: 'text',
+        defaultValue: '',
+        category: 'advanced',
+        isFilePath: true
+    },
+    {
+        key: 'root_path',
+        section: 'beam_pattern',
+        label: 'Caminho raiz de saída',
+        tooltip: 'Nome raiz dos arquivos de saída. Sufixos e extensões serão adicionados automaticamente.',
+        type: 'text',
+        defaultValue: '',
+        category: 'essential',
+        required: true,
+        isFilePath: true
+    },
+    {
+        key: 'output/separate_time_and_channel',
+        section: 'beam_pattern',
+        label: 'Separar tempo e canal',
+        tooltip: 'Se true, gera arquivos de saída sem fazer média sobre tempo ou canal.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'output/average_time_and_channel',
+        section: 'beam_pattern',
+        label: 'Média de tempo e canal',
+        tooltip: 'Se true, gera arquivos com média sobre tempo e canal.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'recommended',
+        options: [
+            { value: 'true', label: 'Sim' },
+            { value: 'false', label: 'Não' }
+        ]
+    },
+    {
+        key: 'output/average_single_axis',
+        section: 'beam_pattern',
+        label: 'Média em eixo único',
+        tooltip: 'Se definido, faz média sobre o eixo selecionado.',
+        type: 'select',
+        defaultValue: 'None',
+        category: 'advanced',
+        options: [
+            { value: 'None', label: 'Nenhum' },
+            { value: 'Time', label: 'Tempo' },
+            { value: 'Channel', label: 'Canal' }
+        ]
+    },
+
+    // Station outputs - text
+    {
+        key: 'station_outputs/text_file/raw_complex',
+        section: 'beam_pattern',
+        label: 'Texto: complexo bruto',
+        tooltip: 'Se true, salva o padrão complexo bruto em arquivos de texto.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/text_file/amp',
+        section: 'beam_pattern',
+        label: 'Texto: amplitude',
+        tooltip: 'Se true, salva a amplitude (voltagem) em arquivos de texto.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/text_file/phase',
+        section: 'beam_pattern',
+        label: 'Texto: fase',
+        tooltip: 'Se true, salva o padrão de fase em arquivos de texto.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/text_file/auto_power',
+        section: 'beam_pattern',
+        label: 'Texto: auto-potência',
+        tooltip: 'Se true, salva o beam de auto-correlação (intensidade total) em texto.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+
+    // Station outputs - FITS
+    {
+        key: 'station_outputs/fits_image/amp',
+        section: 'beam_pattern',
+        label: 'FITS: amplitude',
+        tooltip: 'Se true, salva a amplitude em imagens FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/fits_image/phase',
+        section: 'beam_pattern',
+        label: 'FITS: fase',
+        tooltip: 'Se true, salva a fase em imagens FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/fits_image/auto_power',
+        section: 'beam_pattern',
+        label: 'FITS: auto-potência',
+        tooltip: 'Se true, salva o beam de auto-correlação em imagens FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'recommended',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/fits_image/auto_power_phase',
+        section: 'beam_pattern',
+        label: 'FITS: fase auto-potência',
+        tooltip: 'Se true, salva a fase da auto-correlação em imagens FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/fits_image/auto_power_real',
+        section: 'beam_pattern',
+        label: 'FITS: parte real auto-potência',
+        tooltip: 'Se true, salva a parte real do beam auto-correlação em FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'station_outputs/fits_image/auto_power_imag',
+        section: 'beam_pattern',
+        label: 'FITS: parte imaginária auto-potência',
+        tooltip: 'Se true, salva a parte imaginária do beam auto-correlação em FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+
+    // Telescope outputs - text
+    {
+        key: 'telescope_outputs/text_file/cross_power_raw_complex',
+        section: 'beam_pattern',
+        label: 'Telescópio texto: cross-power complexo',
+        tooltip: 'Se true, salva a resposta bruta do cross-power beam médio de todas as stations em texto.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'telescope_outputs/text_file/cross_power_amp',
+        section: 'beam_pattern',
+        label: 'Telescópio texto: cross-power amplitude',
+        tooltip: 'Se true, salva a amplitude do cross-power beam médio em texto.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'telescope_outputs/text_file/cross_power_phase',
+        section: 'beam_pattern',
+        label: 'Telescópio texto: cross-power fase',
+        tooltip: 'Se true, salva a fase do cross-power beam médio em texto.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+
+    // Telescope outputs - FITS
+    {
+        key: 'telescope_outputs/fits_image/cross_power_amp',
+        section: 'beam_pattern',
+        label: 'Telescópio FITS: cross-power amplitude',
+        tooltip: 'Se true, salva a amplitude do cross-power beam médio em FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'telescope_outputs/fits_image/cross_power_phase',
+        section: 'beam_pattern',
+        label: 'Telescópio FITS: cross-power fase',
+        tooltip: 'Se true, salva a fase do cross-power beam médio em FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'telescope_outputs/fits_image/cross_power_real',
+        section: 'beam_pattern',
+        label: 'Telescópio FITS: cross-power real',
+        tooltip: 'Se true, salva a parte real do cross-power beam médio em FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'telescope_outputs/fits_image/cross_power_imag',
+        section: 'beam_pattern',
+        label: 'Telescópio FITS: cross-power imaginário',
+        tooltip: 'Se true, salva a parte imaginária do cross-power beam médio em FITS.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+
+    // Test source
+    {
+        key: 'test_source/stokes_i',
+        section: 'beam_pattern',
+        label: 'Fonte de teste Stokes I',
+        tooltip: 'Se true, usa uma fonte de teste Stokes I.',
+        type: 'select',
+        defaultValue: 'true',
+        category: 'recommended',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'test_source/custom',
+        section: 'beam_pattern',
+        label: 'Fonte de teste customizada',
+        tooltip: 'Se true, usa uma fonte de teste customizada com os valores Stokes abaixo.',
+        type: 'select',
+        defaultValue: 'false',
+        category: 'advanced',
+        options: [{ value: 'true', label: 'Sim' }, { value: 'false', label: 'Não' }]
+    },
+    {
+        key: 'test_source/custom_stokes_i',
+        section: 'beam_pattern',
+        label: 'Stokes I (fonte custom)',
+        tooltip: 'Valor Stokes I para a fonte de teste customizada.',
+        type: 'number',
+        defaultValue: 1.0,
+        category: 'advanced'
+    },
+    {
+        key: 'test_source/custom_stokes_q',
+        section: 'beam_pattern',
+        label: 'Stokes Q (fonte custom)',
+        tooltip: 'Valor Stokes Q para a fonte de teste customizada.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'test_source/custom_stokes_u',
+        section: 'beam_pattern',
+        label: 'Stokes U (fonte custom)',
+        tooltip: 'Valor Stokes U para a fonte de teste customizada.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    },
+    {
+        key: 'test_source/custom_stokes_v',
+        section: 'beam_pattern',
+        label: 'Stokes V (fonte custom)',
+        tooltip: 'Valor Stokes V para a fonte de teste customizada.',
+        type: 'number',
+        defaultValue: 0.0,
+        category: 'advanced'
+    }
+]);
+
+/**
+ * Rótulos de seções para o oskar_sim_beam_pattern.
+ * @constant {Object<string, string>}
+ */
+const BEAM_PATTERN_SECTION_LABELS = Object.freeze({
+    simulator: 'Simulador',
+    observation: 'Observação',
+    telescope: 'Telescópio',
+    beam_pattern: 'Beam Pattern'
+});
+
+/**
+ * Classe geradora do arquivo .ini do oskar_sim_beam_pattern.
+ */
+class OskarBeamPatternGenerator {
+    constructor() {
+        /** @type {Object<string, HTMLElement>} */
+        this.inputElements = {};
+
+        this.paramsContainer = document.getElementById('beam-pattern-ini-params-container');
+        this.previewTextarea = document.getElementById('beam-pattern-ini-preview');
+        this.validationContainer = document.getElementById('beam-pattern-ini-validation-messages');
+
+        this._bindButtons();
+        this.renderParameters();
+        this.updatePreview();
+
+        console.log('OskarBeamPatternGenerator inicializado com sucesso.');
+    }
+
+    _bindButtons() {
+        const copyBtn = document.getElementById('beam-pattern-ini-copy-btn');
+        const downloadBtn = document.getElementById('beam-pattern-ini-download-btn');
+
+        if (copyBtn) copyBtn.addEventListener('click', (e) => { e.preventDefault(); this.copyIni(); });
+        if (downloadBtn) downloadBtn.addEventListener('click', (e) => { e.preventDefault(); this.downloadIni(); });
+    }
+
+    renderParameters() {
+        if (!this.paramsContainer) {
+            console.warn('Container beam-pattern-ini-params-container não encontrado no DOM.');
+            return;
+        }
+        this.paramsContainer.innerHTML = '';
+        this.inputElements = {};
+
+        const sectionOrder = ['simulator', 'observation', 'telescope', 'beam_pattern'];
+
+        INI_CATEGORIES.forEach(cat => {
+            const params = OSKAR_BEAM_PATTERN_PARAMS.filter(p => p.category === cat.id);
+            if (params.length === 0) return;
+
+            const catWrapper = document.createElement('div');
+            catWrapper.className = `ini-category ini-category--${cat.id}`;
+
+            const catHeader = document.createElement('div');
+            catHeader.className = 'ini-category__header';
+            catHeader.innerHTML = `<i class="fas ${cat.icon}"></i> <span>${cat.label}</span>`;
+
+            const catBody = document.createElement('div');
+            catBody.className = 'ini-category__body';
+
+            if (cat.collapsible) {
+                catBody.style.display = 'none';
+                const toggleIcon = document.createElement('i');
+                toggleIcon.className = 'fas fa-chevron-down ini-category__toggle';
+                catHeader.appendChild(toggleIcon);
+                catHeader.style.cursor = 'pointer';
+                catHeader.addEventListener('click', () => {
+                    const isHidden = catBody.style.display === 'none';
+                    catBody.style.display = isHidden ? '' : 'none';
+                    toggleIcon.classList.toggle('fa-chevron-down', !isHidden);
+                    toggleIcon.classList.toggle('fa-chevron-up', isHidden);
+                });
+            }
+
+            const grouped = {};
+            params.forEach(p => {
+                if (!grouped[p.section]) grouped[p.section] = [];
+                grouped[p.section].push(p);
+            });
+
+            sectionOrder.forEach(sec => {
+                if (!grouped[sec]) return;
+                const sectionDiv = document.createElement('fieldset');
+                sectionDiv.className = 'ini-section';
+                const legend = document.createElement('legend');
+                legend.textContent = BEAM_PATTERN_SECTION_LABELS[sec] || sec;
+                sectionDiv.appendChild(legend);
+
+                grouped[sec].forEach(param => {
+                    sectionDiv.appendChild(this._createParamRow(param));
+                });
+
+                catBody.appendChild(sectionDiv);
+            });
+
+            catWrapper.appendChild(catHeader);
+            catWrapper.appendChild(catBody);
+            this.paramsContainer.appendChild(catWrapper);
+        });
+    }
+
+    _createParamRow(param) {
+        const row = document.createElement('div');
+        row.className = 'ini-param-row';
+        if (param.required) row.classList.add('ini-param-row--required');
+
+        const label = document.createElement('label');
+        const inputId = `bp-input-${param.section}-${param.key.replace(/[/.]/g, '_')}`;
+        label.setAttribute('for', inputId);
+        label.textContent = param.label;
+        if (param.required) {
+            const req = document.createElement('span');
+            req.className = 'ini-required-mark';
+            req.textContent = ' *';
+            label.appendChild(req);
+        }
+
+        const tooltipIcon = document.createElement('i');
+        tooltipIcon.className = 'fas fa-question-circle ini-tooltip-icon';
+        tooltipIcon.title = param.tooltip;
+        label.appendChild(tooltipIcon);
+
+        let input;
+        if (param.type === 'select' && param.options) {
+            input = document.createElement('select');
+            param.options.forEach(opt => {
+                const option = document.createElement('option');
+                option.value = opt.value;
+                option.textContent = opt.label;
+                if (String(opt.value) === String(param.defaultValue)) option.selected = true;
+                input.appendChild(option);
+            });
+        } else if (param.type === 'checkbox') {
+            input = document.createElement('input');
+            input.type = 'checkbox';
+            input.checked = !!param.defaultValue;
+        } else {
+            input = document.createElement('input');
+            input.type = param.type === 'number' ? 'number' : 'text';
+            if (param.type === 'number') input.step = 'any';
+            input.value = param.defaultValue !== undefined ? param.defaultValue : '';
+        }
+
+        input.id = inputId;
+        input.className = 'ini-param-input';
+        input.dataset.iniKey = param.key;
+        input.dataset.iniSection = param.section;
+
+        input.addEventListener('change', () => this.updatePreview());
+        input.addEventListener('input', () => this.updatePreview());
+
+        const errorSpan = document.createElement('span');
+        errorSpan.className = 'ini-field-error';
+
+        const compositeKey = `${param.section}.${param.key}`;
+        this.inputElements[compositeKey] = input;
+
+        row.appendChild(label);
+
+        if (param.isFilePath) {
+            const inputWrapper = document.createElement('div');
+            inputWrapper.className = 'ini-file-input-wrapper';
+            input.placeholder = param.isDirectory
+                ? 'Ex: /home/user/telescope'
+                : 'Ex: /home/user/data/beam_output';
+            inputWrapper.appendChild(input);
+
+            const browseBtn = document.createElement('button');
+            browseBtn.type = 'button';
+            browseBtn.className = 'ini-browse-btn';
+            browseBtn.title = 'Inserir caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
+            browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
+
+            browseBtn.addEventListener('click', (e) => {
+                e.preventDefault();
+                const lbl = param.isDirectory ? 'diretório' : 'arquivo';
+                const currentVal = input.value || '';
+                const path = prompt(
+                    `Cole o caminho completo do ${lbl} no seu computador:`,
+                    currentVal
+                );
+                if (path !== null && path.trim() !== '') {
+                    input.value = path.trim();
+                    input.dispatchEvent(new Event('input'));
+                }
+            });
+
+            inputWrapper.appendChild(browseBtn);
+            row.appendChild(inputWrapper);
+        } else {
+            row.appendChild(input);
+        }
+
+        row.appendChild(errorSpan);
+        return row;
+    }
+
+    generateIni() {
+        const eol = getOsLineEnding();
+        const sections = {};
+
+        OSKAR_BEAM_PATTERN_PARAMS.forEach(param => {
+            const compositeKey = `${param.section}.${param.key}`;
+            const input = this.inputElements[compositeKey];
+            if (!input) return;
+
+            let value;
+            if (param.type === 'checkbox') {
+                value = input.checked ? 'true' : 'false';
+            } else {
+                value = input.value;
+            }
+
+            if (value === '' && !param.required) return;
+
+            if (!sections[param.section]) sections[param.section] = [];
+            sections[param.section].push({ key: param.key, value });
+        });
+
+        const sectionOrder = ['simulator', 'observation', 'telescope', 'beam_pattern'];
+        const lines = [];
+        lines.push('[General]');
+        lines.push('app=oskar_sim_beam_pattern');
+        lines.push('');
+
+        sectionOrder.forEach(sec => {
+            if (!sections[sec] || sections[sec].length === 0) return;
+            lines.push(`[${sec}]`);
+            sections[sec].forEach(entry => {
+                lines.push(`${entry.key}=${entry.value}`);
+            });
+            lines.push('');
+        });
+
+        return lines.join(eol);
+    }
+
+    updatePreview() {
+        if (!this.previewTextarea) return;
+        this.previewTextarea.value = this.generateIni();
+    }
+
+    validateFields() {
+        let allValid = true;
+        OSKAR_BEAM_PATTERN_PARAMS.forEach(param => {
+            const compositeKey = `${param.section}.${param.key}`;
+            const input = this.inputElements[compositeKey];
+            if (!input) return;
+
+            const row = input.closest('.ini-param-row');
+            const errorSpan = row ? row.querySelector('.ini-field-error') : null;
+            let errorMsg = '';
+
+            const value = (param.type === 'checkbox') ? input.checked : input.value;
+            if (param.required && (value === '' || value === null || value === undefined)) {
+                errorMsg = 'Campo obrigatório.';
+            }
+            if (!errorMsg && param.type === 'number' && value !== '') {
+                if (isNaN(Number(value))) errorMsg = 'Valor numérico inválido.';
+            }
+
+            if (errorMsg) {
+                allValid = false;
+                if (input.classList) input.classList.add('ini-input--error');
+            } else {
+                if (input.classList) input.classList.remove('ini-input--error');
+            }
+            if (errorSpan) errorSpan.textContent = errorMsg;
+        });
+
+        if (this.validationContainer) {
+            this.validationContainer.innerHTML = allValid
+                ? '<span class="ini-validation-ok"><i class="fas fa-check-circle"></i> Todos os campos estão válidos.</span>'
+                : '<span class="ini-validation-error"><i class="fas fa-exclamation-triangle"></i> Campos com erros.</span>';
+        }
+        return allValid;
+    }
+
+    downloadIni() {
+        if (!this.validateFields()) {
+            console.warn('Download cancelado: campos com erro.');
+            return;
+        }
+        const content = this.generateIni();
+        const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = 'oskar_sim_beam_pattern.ini';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        console.log('Arquivo oskar_sim_beam_pattern.ini baixado com sucesso.');
+    }
+
+    copyIni() {
+        const content = this.generateIni();
+        const copyBtn = document.getElementById('beam-pattern-ini-copy-btn');
+
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+            navigator.clipboard.writeText(content).then(() => {
+                this._showCopyFeedback(copyBtn, true);
+            }).catch(() => {
+                this._showCopyFeedback(copyBtn, false);
+            });
+        } else if (this.previewTextarea) {
+            this.previewTextarea.select();
+            document.execCommand('copy');
+            this._showCopyFeedback(copyBtn, true);
+        }
+    }
+
+    _showCopyFeedback(button, success) {
+        if (!button) return;
+        const icon = button.querySelector('i');
+        if (!icon) return;
+        const orig = 'fa-copy';
+        const feedback = success ? 'fa-check' : 'fa-times';
+        icon.classList.remove(orig);
+        icon.classList.add(feedback);
+        button.style.color = success ? 'var(--success-color)' : 'var(--secondary-color)';
+        setTimeout(() => {
+            icon.classList.remove(feedback);
+            icon.classList.add(orig);
+            button.style.color = '';
+        }, 1500);
+    }
+}
+
+// =============================================================================
+// Inicialização
+// =============================================================================
+
+document.addEventListener('DOMContentLoaded', () => {
+    if (!window.oskarIniGenerator) {
+        try {
+            window.oskarIniGenerator = new OskarIniGenerator();
+            console.log('Instância de OskarIniGenerator criada e configurada.');
+        } catch (error) {
+            console.error('Erro ao instanciar OskarIniGenerator:', error);
+        }
+    } else {
+        window.oskarIniGenerator.updatePreview();
+    }
+
+    if (!window.oskarImagerGenerator) {
+        try {
+            window.oskarImagerGenerator = new OskarImagerGenerator();
+            console.log('Instância de OskarImagerGenerator criada e configurada.');
+        } catch (error) {
+            console.error('Erro ao instanciar OskarImagerGenerator:', error);
+        }
+    } else {
+        window.oskarImagerGenerator.updatePreview();
+    }
+
+    if (!window.oskarBeamPatternGenerator) {
+        try {
+            window.oskarBeamPatternGenerator = new OskarBeamPatternGenerator();
+            console.log('Instância de OskarBeamPatternGenerator criada e configurada.');
+        } catch (error) {
+            console.error('Erro ao instanciar OskarBeamPatternGenerator:', error);
+        }
+    } else {
+        window.oskarBeamPatternGenerator.updatePreview();
     }
 });

From 86620435397b2a3dad29a3d6f6841288b6b8cd56 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 00:27:27 +0000
Subject: [PATCH 18/22] Address code review: rename variable and use
 descriptive ID prefix for beam pattern

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/ini_generator.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/js/ini_generator.js b/js/ini_generator.js
index ab71160..01fc770 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -1818,11 +1818,11 @@ class OskarImagerGenerator {
     _bindButtons() {
         const copyBtn = document.getElementById('imager-copy-btn');
         const downloadBtn = document.getElementById('imager-download-btn');
-        const useInterfBtn = document.getElementById('imager-use-interf-output-btn');
+        const useInterferometerBtn = document.getElementById('imager-use-interf-output-btn');
 
         if (copyBtn) copyBtn.addEventListener('click', (e) => { e.preventDefault(); this.copyIni(); });
         if (downloadBtn) downloadBtn.addEventListener('click', (e) => { e.preventDefault(); this.downloadIni(); });
-        if (useInterfBtn) useInterfBtn.addEventListener('click', (e) => { e.preventDefault(); this.useInterferometerOutput(); });
+        if (useInterferometerBtn) useInterferometerBtn.addEventListener('click', (e) => { e.preventDefault(); this.useInterferometerOutput(); });
     }
 
     /**
@@ -3066,7 +3066,7 @@ class OskarBeamPatternGenerator {
         if (param.required) row.classList.add('ini-param-row--required');
 
         const label = document.createElement('label');
-        const inputId = `bp-input-${param.section}-${param.key.replace(/[/.]/g, '_')}`;
+        const inputId = `beam-pattern-input-${param.section}-${param.key.replace(/[/.]/g, '_')}`;
         label.setAttribute('for', inputId);
         label.textContent = param.label;
         if (param.required) {

From 690b5ed834e6e48262d04b84cfa7afb93dc5e41a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 03:30:58 +0000
Subject: [PATCH 19/22] Enhance station layouts, fix file path UX, center sky
 table, remove UV text, add WebGPU, add Ctrl+scroll zoom

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css      |   2 +-
 index.html          |   5 +-
 js/ini_generator.js | 120 +++++++++--------
 js/map.js           |  50 ++++++-
 js/stations.js      | 322 ++++++++++++++++++++++++++++++++++++++++----
 js/uv_coverage.js   | 266 +++++++++++++++++++++++++++++++++---
 6 files changed, 659 insertions(+), 106 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index 4aa563d..d108b9b 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -1223,7 +1223,7 @@ footer { text-align: center; padding: 20px 0; background-color: var(--header-bg-
 .source-table td {
     padding: 6px 10px;
     border-bottom: 1px solid var(--border-color);
-    text-align: right;
+    text-align: center;
 }
 .source-table th {
     background-color: var(--highlight-color);
diff --git a/index.html b/index.html
index 375a9a3..cf9ed01 100644
--- a/index.html
+++ b/index.html
@@ -163,6 +163,10 @@ <h3><i class="fas fa-broadcast-tower"></i> Gerador de Posições de Stations</h3
                         <option value="y_shape">Forma em Y</option>
                         <option value="cross">Cruz</option>
                         <option value="random">Aleatório</option>
+                        <option value="logarithmic">Logarítmico</option>
+                        <option value="sunflower">Girassol (Fibonacci)</option>
+                        <option value="dual_ring">Anéis Duplos</option>
+                        <option value="elliptical">Elíptico</option>
                     </select>
                 </div>
                 <div class="form-group">
@@ -650,7 +654,6 @@ <h3><i class="fas fa-crosshairs"></i> Resolução Angular</h3>
                     </div>
                     <div class="uv-plot-area">
                         <div id="uv-plot-container" class="uv-plot-container">
-                            <div class="plot-placeholder">Clique em "Gerar Cobertura UV" para visualizar o diagrama UV do arranjo.</div>
                         </div>
                         <div id="uv-status" class="status-message">Aguardando geração...</div>
                     </div>
diff --git a/js/ini_generator.js b/js/ini_generator.js
index 01fc770..efb48ce 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -992,38 +992,40 @@ class OskarIniGenerator {
 
         row.appendChild(label);
 
-        // Para campos de arquivo/diretório, cria um wrapper com botão para digitar caminho
+        // Para campos de arquivo/diretório, cria um wrapper com botão para focar/colar caminho
         if (param.isFilePath) {
             const inputWrapper = document.createElement('div');
             inputWrapper.className = 'ini-file-input-wrapper';
             input.placeholder = param.isDirectory
-                ? 'Ex: /home/user/telescope'
-                : 'Ex: /home/user/data/output.vis';
+                ? 'Cole aqui o caminho: /home/user/telescope'
+                : 'Cole aqui o caminho: /home/user/data/output.vis';
+            input.title = 'Digite ou cole o caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
             inputWrapper.appendChild(input);
 
-            const browseBtn = document.createElement('button');
-            browseBtn.type = 'button';
-            browseBtn.className = 'ini-browse-btn';
-            browseBtn.title = 'Inserir caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
-            browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
+            const pasteBtn = document.createElement('button');
+            pasteBtn.type = 'button';
+            pasteBtn.className = 'ini-browse-btn';
+            pasteBtn.title = 'Colar caminho da área de transferência';
+            pasteBtn.innerHTML = '<i class="fas fa-paste"></i>';
 
-            // Navegadores não permitem acesso ao caminho completo por segurança.
-            // Abre um prompt para o usuário colar o caminho completo do seu sistema.
-            browseBtn.addEventListener('click', (e) => {
+            // Ao clicar, tenta colar da área de transferência diretamente no campo
+            pasteBtn.addEventListener('click', async (e) => {
                 e.preventDefault();
-                const label = param.isDirectory ? 'diretório' : 'arquivo';
-                const currentVal = input.value || '';
-                const path = prompt(
-                    `Cole o caminho completo do ${label} no seu computador:`,
-                    currentVal
-                );
-                if (path !== null && path.trim() !== '') {
-                    input.value = path.trim();
-                    input.dispatchEvent(new Event('input'));
+                try {
+                    const text = await navigator.clipboard.readText();
+                    if (text && text.trim()) {
+                        input.value = text.trim();
+                        input.dispatchEvent(new Event('input'));
+                        input.focus();
+                    }
+                } catch (_err) {
+                    // Fallback: foca e seleciona o campo para o usuário colar manualmente
+                    input.focus();
+                    input.select();
                 }
             });
 
-            inputWrapper.appendChild(browseBtn);
+            inputWrapper.appendChild(pasteBtn);
             row.appendChild(inputWrapper);
         } else {
             row.appendChild(input);
@@ -1979,31 +1981,33 @@ class OskarImagerGenerator {
             const inputWrapper = document.createElement('div');
             inputWrapper.className = 'ini-file-input-wrapper';
             input.placeholder = param.isDirectory
-                ? 'Ex: /home/user/telescope'
-                : 'Ex: /home/user/data/output.vis';
+                ? 'Cole aqui o caminho: /home/user/telescope'
+                : 'Cole aqui o caminho: /home/user/data/output.vis';
+            input.title = 'Digite ou cole o caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
             inputWrapper.appendChild(input);
 
-            const browseBtn = document.createElement('button');
-            browseBtn.type = 'button';
-            browseBtn.className = 'ini-browse-btn';
-            browseBtn.title = 'Inserir caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
-            browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
+            const pasteBtn = document.createElement('button');
+            pasteBtn.type = 'button';
+            pasteBtn.className = 'ini-browse-btn';
+            pasteBtn.title = 'Colar caminho da área de transferência';
+            pasteBtn.innerHTML = '<i class="fas fa-paste"></i>';
 
-            browseBtn.addEventListener('click', (e) => {
+            pasteBtn.addEventListener('click', async (e) => {
                 e.preventDefault();
-                const label = param.isDirectory ? 'diretório' : 'arquivo';
-                const currentVal = input.value || '';
-                const path = prompt(
-                    `Cole o caminho completo do ${label} no seu computador:`,
-                    currentVal
-                );
-                if (path !== null && path.trim() !== '') {
-                    input.value = path.trim();
-                    input.dispatchEvent(new Event('input'));
+                try {
+                    const text = await navigator.clipboard.readText();
+                    if (text && text.trim()) {
+                        input.value = text.trim();
+                        input.dispatchEvent(new Event('input'));
+                        input.focus();
+                    }
+                } catch (_err) {
+                    input.focus();
+                    input.select();
                 }
             });
 
-            inputWrapper.appendChild(browseBtn);
+            inputWrapper.appendChild(pasteBtn);
             row.appendChild(inputWrapper);
         } else {
             row.appendChild(input);
@@ -3122,31 +3126,33 @@ class OskarBeamPatternGenerator {
             const inputWrapper = document.createElement('div');
             inputWrapper.className = 'ini-file-input-wrapper';
             input.placeholder = param.isDirectory
-                ? 'Ex: /home/user/telescope'
-                : 'Ex: /home/user/data/beam_output';
+                ? 'Cole aqui o caminho: /home/user/telescope'
+                : 'Cole aqui o caminho: /home/user/data/beam_output';
+            input.title = 'Digite ou cole o caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
             inputWrapper.appendChild(input);
 
-            const browseBtn = document.createElement('button');
-            browseBtn.type = 'button';
-            browseBtn.className = 'ini-browse-btn';
-            browseBtn.title = 'Inserir caminho completo do ' + (param.isDirectory ? 'diretório' : 'arquivo');
-            browseBtn.innerHTML = '<i class="fas fa-folder-open"></i>';
+            const pasteBtn = document.createElement('button');
+            pasteBtn.type = 'button';
+            pasteBtn.className = 'ini-browse-btn';
+            pasteBtn.title = 'Colar caminho da área de transferência';
+            pasteBtn.innerHTML = '<i class="fas fa-paste"></i>';
 
-            browseBtn.addEventListener('click', (e) => {
+            pasteBtn.addEventListener('click', async (e) => {
                 e.preventDefault();
-                const lbl = param.isDirectory ? 'diretório' : 'arquivo';
-                const currentVal = input.value || '';
-                const path = prompt(
-                    `Cole o caminho completo do ${lbl} no seu computador:`,
-                    currentVal
-                );
-                if (path !== null && path.trim() !== '') {
-                    input.value = path.trim();
-                    input.dispatchEvent(new Event('input'));
+                try {
+                    const text = await navigator.clipboard.readText();
+                    if (text && text.trim()) {
+                        input.value = text.trim();
+                        input.dispatchEvent(new Event('input'));
+                        input.focus();
+                    }
+                } catch (_err) {
+                    input.focus();
+                    input.select();
                 }
             });
 
-            inputWrapper.appendChild(browseBtn);
+            inputWrapper.appendChild(pasteBtn);
             row.appendChild(inputWrapper);
         } else {
             row.appendChild(input);
diff --git a/js/map.js b/js/map.js
index 6cea377..7a8513d 100644
--- a/js/map.js
+++ b/js/map.js
@@ -110,9 +110,13 @@ class InteractiveMap {
         const osmMaxZoom = 19;
 
         this.map = L.map('map', {
-            maxZoom: maxZoomLevel 
+            maxZoom: maxZoomLevel,
+            scrollWheelZoom: false  // Desabilitado por padrão, requer Ctrl+scroll
         }).setView([BINGO_LATITUDE, BINGO_LONGITUDE], 10);
 
+        // Ctrl+Scroll zoom: habilita scroll zoom apenas com Ctrl pressionado
+        this._setupCtrlScrollZoom();
+
         const osmLayer = L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
             attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
             maxZoom: osmMaxZoom
@@ -230,6 +234,50 @@ class InteractiveMap {
         console.log("Mapa Leaflet inicializado.");
     }
 
+    /**
+     * Configura o comportamento Ctrl+Scroll para zoom no mapa.
+     * Scroll sem Ctrl apenas rola a página normalmente.
+     * Exibe mensagem de orientação quando o usuário tenta dar scroll sem Ctrl.
+     */
+    _setupCtrlScrollZoom() {
+        const mapContainer = this.map.getContainer();
+
+        // Cria overlay de mensagem
+        const overlay = document.createElement('div');
+        overlay.className = 'map-scroll-overlay';
+        overlay.textContent = 'Use Ctrl + scroll para dar zoom no mapa';
+        overlay.style.cssText = 'position:absolute;top:0;left:0;width:100%;height:100%;' +
+            'display:flex;align-items:center;justify-content:center;' +
+            'background:rgba(0,0,0,0.5);color:#fff;font-size:16px;font-weight:600;' +
+            'z-index:1000;pointer-events:none;opacity:0;transition:opacity 0.3s;' +
+            'text-shadow:0 1px 3px rgba(0,0,0,0.8);border-radius:8px;';
+        mapContainer.style.position = 'relative';
+        mapContainer.appendChild(overlay);
+
+        let overlayTimeout = null;
+
+        const showOverlay = () => {
+            overlay.style.opacity = '1';
+            if (overlayTimeout) clearTimeout(overlayTimeout);
+            overlayTimeout = setTimeout(() => { overlay.style.opacity = '0'; }, 1500);
+        };
+
+        // Intercepta eventos de wheel no container do mapa
+        mapContainer.addEventListener('wheel', (e) => {
+            if (e.ctrlKey || e.metaKey) {
+                // Ctrl pressionado: habilita zoom e previne scroll da página
+                e.preventDefault();
+                // Aplica zoom manualmente
+                const delta = e.deltaY > 0 ? -1 : 1;
+                const currentZoom = this.map.getZoom();
+                this.map.setZoom(currentZoom + delta, { animate: true });
+            } else {
+                // Sem Ctrl: mostra mensagem de orientação (a página rola normalmente)
+                showOverlay();
+            }
+        }, { passive: false });
+    }
+
     // initControls() - sem alterações na lógica interna
     initControls() {
         const arranjoSelect = document.getElementById('arranjo-select');
diff --git a/js/stations.js b/js/stations.js
index 3bb638c..0bca430 100644
--- a/js/stations.js
+++ b/js/stations.js
@@ -191,33 +191,74 @@ class StationManager {
                 { id: 'sp-grid-cols', label: 'Colunas', type: 'number', value: 0, min: 0, max: 50, step: 1, hint: '0 = automático (√N)' },
                 { id: 'sp-grid-sx', label: 'Fator Espaç. X', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
                 { id: 'sp-grid-sy', label: 'Fator Espaç. Y', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
-                { id: 'sp-grid-jitter', label: 'Jitter aleatório (m)', type: 'number', value: 0, min: 0, max: 100, step: 1 }
+                { id: 'sp-grid-jitter', label: 'Jitter aleatório (m)', type: 'number', value: 0, min: 0, max: 100, step: 1 },
+                { id: 'sp-grid-exp', label: 'Crescimento exponencial', type: 'number', value: 1.0, min: 0.5, max: 3.0, step: 0.1, hint: '1.0 = uniforme, >1 = espaço cresce' },
+                { id: 'sp-grid-rot', label: 'Rotação do grid (°)', type: 'number', value: 0, min: 0, max: 90, step: 5 }
             ],
             circular: [
                 { id: 'sp-circ-rings', label: 'Número de anéis', type: 'number', value: 1, min: 1, max: 10, step: 1 },
                 { id: 'sp-circ-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 },
-                { id: 'sp-circ-inner', label: 'Raio interno (fração)', type: 'number', value: 0.5, min: 0.1, max: 1.0, step: 0.05 }
+                { id: 'sp-circ-inner', label: 'Raio interno (fração)', type: 'number', value: 0.5, min: 0.1, max: 1.0, step: 0.05 },
+                { id: 'sp-circ-exp', label: 'Crescimento exponencial', type: 'number', value: 1.0, min: 0.5, max: 3.0, step: 0.1, hint: '1.0 = uniforme, >1 = anéis se afastam' },
+                { id: 'sp-circ-jitter', label: 'Jitter radial (m)', type: 'number', value: 0, min: 0, max: 100, step: 1 }
             ],
             spiral: [
                 { id: 'sp-spiral-turns', label: 'Número de voltas', type: 'number', value: 3, min: 1, max: 20, step: 0.5 },
                 { id: 'sp-spiral-growth', label: 'Fator de crescimento', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
-                { id: 'sp-spiral-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 }
+                { id: 'sp-spiral-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 },
+                { id: 'sp-spiral-arms', label: 'Nº de braços espirais', type: 'number', value: 1, min: 1, max: 6, step: 1, hint: '1 = espiral simples' },
+                { id: 'sp-spiral-exp', label: 'Separação exponencial', type: 'number', value: 1.0, min: 0.5, max: 3.0, step: 0.1, hint: '1 = linear, >1 = acelera' },
+                { id: 'sp-spiral-jitter', label: 'Jitter (m)', type: 'number', value: 0, min: 0, max: 100, step: 1 }
             ],
             y_shape: [
                 { id: 'sp-y-arms', label: 'Número de braços', type: 'number', value: 3, min: 2, max: 8, step: 1 },
                 { id: 'sp-y-angle', label: 'Ângulo inicial (°)', type: 'number', value: 90, min: 0, max: 360, step: 5 },
                 { id: 'sp-y-curve', label: 'Curvatura dos braços', type: 'number', value: 0, min: -0.5, max: 0.5, step: 0.05 },
-                { id: 'sp-y-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '0' }
+                { id: 'sp-y-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '0' },
+                { id: 'sp-y-exp', label: 'Separação exponencial', type: 'number', value: 1.0, min: 0.5, max: 3.0, step: 0.1, hint: '1 = uniforme, >1 = espaço cresce no braço' },
+                { id: 'sp-y-taper', label: 'Taper (afunilamento)', type: 'number', value: 0, min: -1, max: 1, step: 0.1, hint: '>0 mais estações perto do centro' }
             ],
             cross: [
                 { id: 'sp-cross-angle', label: 'Ângulo de rotação (°)', type: 'number', value: 0, min: 0, max: 90, step: 5 },
                 { id: 'sp-cross-spacing-ratio', label: 'Proporção espaç. vert/horiz', type: 'number', value: 1.0, min: 0.1, max: 5, step: 0.1 },
-                { id: 'sp-cross-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '0' }
+                { id: 'sp-cross-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '0' },
+                { id: 'sp-cross-exp', label: 'Separação exponencial', type: 'number', value: 1.0, min: 0.5, max: 3.0, step: 0.1, hint: '1 = uniforme, >1 = cresce' }
             ],
             random: [
-                { id: 'sp-rand-shape', label: 'Forma da área', type: 'select', options: [{ v: 'circle', t: 'Círculo' }, { v: 'square', t: 'Quadrado' }], value: 'circle' },
+                { id: 'sp-rand-shape', label: 'Forma da área', type: 'select', options: [{ v: 'circle', t: 'Círculo' }, { v: 'square', t: 'Quadrado' }, { v: 'ellipse', t: 'Elipse' }], value: 'circle' },
                 { id: 'sp-rand-mindist', label: 'Distância mín. entre stations (m)', type: 'number', value: 0, min: 0, max: 500, step: 5 },
-                { id: 'sp-rand-seed', label: 'Semente (0 = aleatório)', type: 'number', value: 0, min: 0, max: 99999, step: 1 }
+                { id: 'sp-rand-seed', label: 'Semente (0 = aleatório)', type: 'number', value: 0, min: 0, max: 99999, step: 1 },
+                { id: 'sp-rand-dist', label: 'Distribuição radial', type: 'select', options: [
+                    { v: 'uniform', t: 'Uniforme' },
+                    { v: 'gaussian', t: 'Gaussiana (concentrada no centro)' },
+                    { v: 'exponential', t: 'Exponencial (decai do centro)' }
+                ], value: 'uniform' },
+                { id: 'sp-rand-sigma', label: 'Sigma da distribuição', type: 'number', value: 0.5, min: 0.1, max: 2.0, step: 0.1, hint: 'Aplica-se a gaussian/exponencial' }
+            ],
+            logarithmic: [
+                { id: 'sp-log-arms', label: 'Nº de braços', type: 'number', value: 3, min: 1, max: 8, step: 1 },
+                { id: 'sp-log-pitch', label: 'Ângulo de pitch (°)', type: 'number', value: 25, min: 5, max: 80, step: 1, hint: 'Abertura da espiral logarítmica' },
+                { id: 'sp-log-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 },
+                { id: 'sp-log-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '1' },
+                { id: 'sp-log-jitter', label: 'Jitter (m)', type: 'number', value: 0, min: 0, max: 100, step: 1 }
+            ],
+            sunflower: [
+                { id: 'sp-sun-alpha', label: 'Fator de dispersão (α)', type: 'number', value: 1, min: 0, max: 5, step: 0.1, hint: '0 = Fibonacci puro, >0 = mais espaço na borda' },
+                { id: 'sp-sun-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 },
+                { id: 'sp-sun-exp', label: 'Crescimento radial', type: 'number', value: 0.5, min: 0.1, max: 2.0, step: 0.05, hint: '0.5 = padrão Fibonacci, >0.5 = mais disperso' }
+            ],
+            dual_ring: [
+                { id: 'sp-dr-ratio', label: 'Proporção interno/externo', type: 'number', value: 0.4, min: 0.1, max: 0.9, step: 0.05, hint: 'Fração de estações no anel interno' },
+                { id: 'sp-dr-inner-r', label: 'Raio interno (fração)', type: 'number', value: 0.35, min: 0.1, max: 0.8, step: 0.05 },
+                { id: 'sp-dr-offset', label: 'Offset angular (°)', type: 'number', value: 0, min: 0, max: 360, step: 5 },
+                { id: 'sp-dr-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '0' }
+            ],
+            elliptical: [
+                { id: 'sp-ell-ratio', label: 'Razão de eixos (b/a)', type: 'number', value: 0.6, min: 0.1, max: 1.0, step: 0.05, hint: '1.0 = círculo' },
+                { id: 'sp-ell-rot', label: 'Rotação da elipse (°)', type: 'number', value: 0, min: 0, max: 180, step: 5 },
+                { id: 'sp-ell-rings', label: 'Nº de anéis', type: 'number', value: 2, min: 1, max: 10, step: 1 },
+                { id: 'sp-ell-exp', label: 'Crescimento exponencial', type: 'number', value: 1.0, min: 0.5, max: 3.0, step: 0.1 },
+                { id: 'sp-ell-core', label: 'Estação central', type: 'select', options: [{ v: '1', t: 'Sim' }, { v: '0', t: 'Não' }], value: '1' }
             ]
         };
 
@@ -269,6 +310,18 @@ class StationManager {
             case 'random':
                 this.stations = this.generateRandomStations(count, spacing);
                 break;
+            case 'logarithmic':
+                this.stations = this.generateLogarithmicStations(count, spacing);
+                break;
+            case 'sunflower':
+                this.stations = this.generateSunflowerStations(count, spacing);
+                break;
+            case 'dual_ring':
+                this.stations = this.generateDualRingStations(count, spacing);
+                break;
+            case 'elliptical':
+                this.stations = this.generateEllipticalStations(count, spacing);
+                break;
             default:
                 console.warn(`StationManager: Tipo de layout desconhecido '${layoutType}'. Usando grid.`);
                 this.stations = this.generateGridStations(count, spacing);
@@ -392,18 +445,30 @@ class StationManager {
         const sx = this._getExtraParam('sp-grid-sx', 1.0);
         const sy = this._getExtraParam('sp-grid-sy', 1.0);
         const jitter = this._getExtraParam('sp-grid-jitter', 0);
+        const expGrowth = this._getExtraParam('sp-grid-exp', 1.0);
+        const rotDeg = this._getExtraParam('sp-grid-rot', 0);
+        const rotRad = rotDeg * Math.PI / 180;
 
         const cols = (forcedCols > 0) ? forcedCols : Math.ceil(Math.sqrt(count));
         const rows = Math.ceil(count / cols);
         const positions = [];
         for (let r = 0; r < rows && positions.length < count; r++) {
             for (let c = 0; c < cols && positions.length < count; c++) {
-                let x = c * spacing * sx;
-                let y = r * spacing * sy;
+                // Espaçamento exponencial: distância cresce com o índice
+                const xSpacing = spacing * sx * Math.pow(c + 1, expGrowth) / Math.pow(1, expGrowth);
+                const ySpacing = spacing * sy * Math.pow(r + 1, expGrowth) / Math.pow(1, expGrowth);
+                let x = (expGrowth === 1.0) ? c * spacing * sx : xSpacing - spacing * sx;
+                let y = (expGrowth === 1.0) ? r * spacing * sy : ySpacing - spacing * sy;
                 if (jitter > 0) {
                     x += (Math.random() - 0.5) * 2 * jitter;
                     y += (Math.random() - 0.5) * 2 * jitter;
                 }
+                // Aplica rotação
+                if (rotRad !== 0) {
+                    const xr = x * Math.cos(rotRad) - y * Math.sin(rotRad);
+                    const yr = x * Math.sin(rotRad) + y * Math.cos(rotRad);
+                    x = xr; y = yr;
+                }
                 positions.push({ x, y });
             }
         }
@@ -417,6 +482,8 @@ class StationManager {
         const rings = this._getExtraParam('sp-circ-rings', 1);
         const offsetDeg = this._getExtraParam('sp-circ-offset', 0);
         const innerFrac = this._getExtraParam('sp-circ-inner', 0.5);
+        const expGrowth = this._getExtraParam('sp-circ-exp', 1.0);
+        const jitter = this._getExtraParam('sp-circ-jitter', 0);
 
         const positions = [];
         const offsetRad = offsetDeg * Math.PI / 180;
@@ -425,19 +492,33 @@ class StationManager {
             const radius = spacing;
             for (let i = 0; i < count; i++) {
                 const angle = (2 * Math.PI * i) / count + offsetRad;
-                positions.push({ x: radius * Math.cos(angle), y: radius * Math.sin(angle) });
+                let x = radius * Math.cos(angle);
+                let y = radius * Math.sin(angle);
+                if (jitter > 0) {
+                    x += (Math.random() - 0.5) * 2 * jitter;
+                    y += (Math.random() - 0.5) * 2 * jitter;
+                }
+                positions.push({ x, y });
             }
         } else {
             const perRing = Math.max(1, Math.floor(count / rings));
             let remaining = count;
             for (let ring = 0; ring < rings && remaining > 0; ring++) {
-                const frac = rings === 1 ? 1 : innerFrac + (1 - innerFrac) * (ring / (rings - 1));
+                // Crescimento exponencial entre anéis
+                const t = rings === 1 ? 1 : ring / (rings - 1);
+                const frac = innerFrac + (1 - innerFrac) * Math.pow(t, expGrowth);
                 const radius = spacing * frac;
                 const n = (ring === rings - 1) ? remaining : Math.min(perRing, remaining);
                 const ringOffset = offsetRad + (ring % 2 === 1 ? Math.PI / n : 0);
                 for (let i = 0; i < n; i++) {
                     const angle = (2 * Math.PI * i) / n + ringOffset;
-                    positions.push({ x: radius * Math.cos(angle), y: radius * Math.sin(angle) });
+                    let x = radius * Math.cos(angle);
+                    let y = radius * Math.sin(angle);
+                    if (jitter > 0) {
+                        x += (Math.random() - 0.5) * 2 * jitter;
+                        y += (Math.random() - 0.5) * 2 * jitter;
+                    }
+                    positions.push({ x, y });
                 }
                 remaining -= n;
             }
@@ -452,14 +533,30 @@ class StationManager {
         const turns = this._getExtraParam('sp-spiral-turns', 3);
         const growth = this._getExtraParam('sp-spiral-growth', 1.0);
         const offsetDeg = this._getExtraParam('sp-spiral-offset', 0);
+        const numArms = Math.max(1, this._getExtraParam('sp-spiral-arms', 1));
+        const expSep = this._getExtraParam('sp-spiral-exp', 1.0);
+        const jitter = this._getExtraParam('sp-spiral-jitter', 0);
         const offsetRad = offsetDeg * Math.PI / 180;
 
         const positions = [];
-        for (let i = 0; i < count; i++) {
-            const t = (i + 1) / count; // 0..1
-            const r = spacing * Math.pow(t, growth);
-            const theta = 2 * Math.PI * turns * t + offsetRad;
-            positions.push({ x: r * Math.cos(theta), y: r * Math.sin(theta) });
+        const perArm = Math.floor(count / numArms);
+        const remainder = count - perArm * numArms;
+
+        for (let a = 0; a < numArms; a++) {
+            const armCount = perArm + (a < remainder ? 1 : 0);
+            const armOffset = (2 * Math.PI * a) / numArms;
+            for (let i = 0; i < armCount; i++) {
+                const t = (i + 1) / armCount;
+                const r = spacing * Math.pow(t, growth) * Math.pow(t, expSep - 1);
+                const theta = 2 * Math.PI * turns * t + offsetRad + armOffset;
+                let x = r * Math.cos(theta);
+                let y = r * Math.sin(theta);
+                if (jitter > 0) {
+                    x += (Math.random() - 0.5) * 2 * jitter;
+                    y += (Math.random() - 0.5) * 2 * jitter;
+                }
+                positions.push({ x, y });
+            }
         }
         return positions;
     }
@@ -472,6 +569,8 @@ class StationManager {
         const angleDeg = this._getExtraParam('sp-y-angle', 90);
         const curve = this._getExtraParam('sp-y-curve', 0);
         const addCore = this._getExtraParam('sp-y-core', 0) === 1;
+        const expSep = this._getExtraParam('sp-y-exp', 1.0);
+        const taper = this._getExtraParam('sp-y-taper', 0);
 
         const positions = [];
         const baseAngle = angleDeg * Math.PI / 180;
@@ -481,17 +580,23 @@ class StationManager {
         }
         if (stationsLeft < 1) return positions;
 
-        const perArm = Math.floor(stationsLeft / arms);
+        // Taper: redistribui estações entre braços (mais perto do centro com taper > 0)
+        let perArm = Math.floor(stationsLeft / arms);
         const remainder = stationsLeft - perArm * arms;
 
         for (let a = 0; a < arms; a++) {
             const stationsInArm = perArm + (a < remainder ? 1 : 0);
             const armAngle = baseAngle + (2 * Math.PI * a) / arms;
             for (let i = 0; i < stationsInArm; i++) {
-                const dist = spacing * (i + 1);
+                const t = (i + 1) / stationsInArm;
+                // Separação exponencial: espaço entre estações cresce
+                const dist = spacing * Math.pow(t, expSep) * stationsInArm;
+                // Taper: ajusta distribuição ao longo do braço
+                const taperFactor = 1 - taper * (1 - t);
+                const finalDist = dist * Math.max(0.1, taperFactor);
                 const curveAngle = curve * (i + 1) * (i + 1) / stationsInArm;
                 const angle = armAngle + curveAngle;
-                positions.push({ x: dist * Math.cos(angle), y: dist * Math.sin(angle) });
+                positions.push({ x: finalDist * Math.cos(angle), y: finalDist * Math.sin(angle) });
             }
         }
         return positions;
@@ -504,6 +609,7 @@ class StationManager {
         const rotDeg = this._getExtraParam('sp-cross-angle', 0);
         const spacingRatio = this._getExtraParam('sp-cross-spacing-ratio', 1.0);
         const addCore = this._getExtraParam('sp-cross-core', 0) === 1;
+        const expSep = this._getExtraParam('sp-cross-exp', 1.0);
 
         const rotRad = rotDeg * Math.PI / 180;
         const positions = [];
@@ -523,7 +629,8 @@ class StationManager {
             const armAngle = armAngles[a] + rotRad;
             const spc = (a === 1 || a === 3) ? spacing * spacingRatio : spacing;
             for (let i = 0; i < stationsInArm; i++) {
-                const dist = spc * (i + 1);
+                // Separação exponencial: distância cresce ao longo do braço
+                const dist = spc * Math.pow((i + 1) / 1, expSep);
                 positions.push({ x: dist * Math.cos(armAngle), y: dist * Math.sin(armAngle) });
             }
         }
@@ -537,6 +644,8 @@ class StationManager {
         const shape = (() => { const el = document.getElementById('sp-rand-shape'); return el ? el.value : 'circle'; })();
         const minDist = this._getExtraParam('sp-rand-mindist', 0);
         const seed = this._getExtraParam('sp-rand-seed', 0);
+        const distType = (() => { const el = document.getElementById('sp-rand-dist'); return el ? el.value : 'uniform'; })();
+        const sigma = this._getExtraParam('sp-rand-sigma', 0.5);
 
         // Pseudo-random with seed using Park-Miller MINSTD algorithm
         let rng;
@@ -549,6 +658,12 @@ class StationManager {
             rng = Math.random;
         }
 
+        // Box-Muller para distribuição gaussiana
+        const gaussRng = () => {
+            const u1 = rng(), u2 = rng();
+            return Math.sqrt(-2 * Math.log(u1 || 1e-10)) * Math.cos(2 * Math.PI * u2);
+        };
+
         const area = spacing * Math.sqrt(count);
         const positions = [];
         const maxAttempts = count * 200;
@@ -557,14 +672,33 @@ class StationManager {
         while (positions.length < count && attempts < maxAttempts) {
             attempts++;
             let x, y;
-            if (shape === 'circle') {
-                const r = area * Math.sqrt(rng());
+
+            if (distType === 'gaussian') {
+                // Distribuição gaussiana: concentra estações no centro
+                x = gaussRng() * area * sigma;
+                y = gaussRng() * area * sigma;
+            } else if (distType === 'exponential') {
+                // Distribuição exponencial: decai do centro
+                const r = -area * sigma * Math.log(rng() || 1e-10);
                 const theta = 2 * Math.PI * rng();
                 x = r * Math.cos(theta);
                 y = r * Math.sin(theta);
             } else {
-                x = (rng() - 0.5) * 2 * area;
-                y = (rng() - 0.5) * 2 * area;
+                // Uniforme (padrão)
+                if (shape === 'circle') {
+                    const r = area * Math.sqrt(rng());
+                    const theta = 2 * Math.PI * rng();
+                    x = r * Math.cos(theta);
+                    y = r * Math.sin(theta);
+                } else if (shape === 'ellipse') {
+                    const r = area * Math.sqrt(rng());
+                    const theta = 2 * Math.PI * rng();
+                    x = r * Math.cos(theta);
+                    y = r * 0.6 * Math.sin(theta);
+                } else {
+                    x = (rng() - 0.5) * 2 * area;
+                    y = (rng() - 0.5) * 2 * area;
+                }
             }
 
             if (minDist > 0) {
@@ -583,6 +717,144 @@ class StationManager {
         return positions;
     }
 
+    /**
+     * Gera estações em espiral logarítmica com múltiplos braços.
+     * A espiral logarítmica é definida como r = a * e^(b*θ) onde b = tan(pitch).
+     */
+    generateLogarithmicStations(count, spacing) {
+        const numArms = Math.max(1, this._getExtraParam('sp-log-arms', 3));
+        const pitchDeg = this._getExtraParam('sp-log-pitch', 25);
+        const offsetDeg = this._getExtraParam('sp-log-offset', 0);
+        const addCore = this._getExtraParam('sp-log-core', 1) === 1;
+        const jitter = this._getExtraParam('sp-log-jitter', 0);
+        const offsetRad = offsetDeg * Math.PI / 180;
+        const pitchRad = pitchDeg * Math.PI / 180;
+        const b = Math.tan(pitchRad);
+
+        const positions = [];
+        let stationsLeft = addCore ? count - 1 : count;
+        if (addCore) positions.push({ x: 0, y: 0 });
+        if (stationsLeft < 1) return positions;
+
+        const perArm = Math.floor(stationsLeft / numArms);
+        const remainder = stationsLeft - perArm * numArms;
+        const minRadius = spacing * 0.1;
+
+        for (let a = 0; a < numArms; a++) {
+            const armCount = perArm + (a < remainder ? 1 : 0);
+            const armAngle = (2 * Math.PI * a) / numArms + offsetRad;
+            for (let i = 0; i < armCount; i++) {
+                const t = (i + 1) / armCount;
+                const theta = t * 4 * Math.PI; // ~2 full turns
+                const r = minRadius * Math.exp(b * theta);
+                const scaledR = Math.min(r, spacing); // Cap at spacing
+                const finalR = minRadius + (scaledR - minRadius) * (spacing / scaledR || 1);
+                const angle = theta + armAngle;
+                let x = finalR * Math.cos(angle);
+                let y = finalR * Math.sin(angle);
+                if (jitter > 0) {
+                    x += (Math.random() - 0.5) * 2 * jitter;
+                    y += (Math.random() - 0.5) * 2 * jitter;
+                }
+                positions.push({ x, y });
+            }
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações usando padrão girassol (Fibonacci/Vogel).
+     * Distribui pontos uniformemente usando o ângulo dourado: θ = n × 137.508°.
+     */
+    generateSunflowerStations(count, spacing) {
+        const alpha = this._getExtraParam('sp-sun-alpha', 1);
+        const offsetDeg = this._getExtraParam('sp-sun-offset', 0);
+        const radialExp = this._getExtraParam('sp-sun-exp', 0.5);
+        const offsetRad = offsetDeg * Math.PI / 180;
+        const goldenAngle = Math.PI * (3 - Math.sqrt(5)); // ~137.508°
+
+        const positions = [];
+        for (let i = 0; i < count; i++) {
+            const n = i + alpha;
+            const r = spacing * Math.pow(n / count, radialExp);
+            const theta = i * goldenAngle + offsetRad;
+            positions.push({ x: r * Math.cos(theta), y: r * Math.sin(theta) });
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações em dois anéis concêntricos com proporção configurável.
+     * Ideal para arrays com núcleo denso e anel externo esparso.
+     */
+    generateDualRingStations(count, spacing) {
+        const innerRatio = this._getExtraParam('sp-dr-ratio', 0.4);
+        const innerRadiusFrac = this._getExtraParam('sp-dr-inner-r', 0.35);
+        const offsetDeg = this._getExtraParam('sp-dr-offset', 0);
+        const addCore = this._getExtraParam('sp-dr-core', 0) === 1;
+        const offsetRad = offsetDeg * Math.PI / 180;
+
+        const positions = [];
+        let stationsLeft = addCore ? count - 1 : count;
+        if (addCore) positions.push({ x: 0, y: 0 });
+        if (stationsLeft < 1) return positions;
+
+        const innerCount = Math.max(1, Math.round(stationsLeft * innerRatio));
+        const outerCount = stationsLeft - innerCount;
+        const innerRadius = spacing * innerRadiusFrac;
+        const outerRadius = spacing;
+
+        // Anel interno
+        for (let i = 0; i < innerCount; i++) {
+            const angle = (2 * Math.PI * i) / innerCount + offsetRad;
+            positions.push({ x: innerRadius * Math.cos(angle), y: innerRadius * Math.sin(angle) });
+        }
+        // Anel externo (com offset de meio passo angular)
+        for (let i = 0; i < outerCount; i++) {
+            const angle = (2 * Math.PI * i) / outerCount + offsetRad + Math.PI / outerCount;
+            positions.push({ x: outerRadius * Math.cos(angle), y: outerRadius * Math.sin(angle) });
+        }
+        return positions;
+    }
+
+    /**
+     * Gera estações em anéis elípticos.
+     * Similar ao circular, mas com razão de eixos e rotação configuráveis.
+     */
+    generateEllipticalStations(count, spacing) {
+        const axisRatio = this._getExtraParam('sp-ell-ratio', 0.6);
+        const rotDeg = this._getExtraParam('sp-ell-rot', 0);
+        const rings = Math.max(1, this._getExtraParam('sp-ell-rings', 2));
+        const expGrowth = this._getExtraParam('sp-ell-exp', 1.0);
+        const addCore = this._getExtraParam('sp-ell-core', 1) === 1;
+        const rotRad = rotDeg * Math.PI / 180;
+
+        const positions = [];
+        let stationsLeft = addCore ? count - 1 : count;
+        if (addCore) positions.push({ x: 0, y: 0 });
+        if (stationsLeft < 1) return positions;
+
+        const perRing = Math.max(1, Math.floor(stationsLeft / rings));
+        let remaining = stationsLeft;
+
+        for (let ring = 0; ring < rings && remaining > 0; ring++) {
+            const t = rings === 1 ? 1 : (ring + 1) / rings;
+            const radius = spacing * Math.pow(t, expGrowth);
+            const n = (ring === rings - 1) ? remaining : Math.min(perRing, remaining);
+            for (let i = 0; i < n; i++) {
+                const angle = (2 * Math.PI * i) / n;
+                let x = radius * Math.cos(angle);
+                let y = radius * axisRatio * Math.sin(angle);
+                // Aplica rotação
+                const xr = x * Math.cos(rotRad) - y * Math.sin(rotRad);
+                const yr = x * Math.sin(rotRad) + y * Math.cos(rotRad);
+                positions.push({ x: xr, y: yr });
+            }
+            remaining -= n;
+        }
+        return positions;
+    }
+
     // ===========================
     // Cálculos de Baselines
     // ===========================
diff --git a/js/uv_coverage.js b/js/uv_coverage.js
index 61973ef..da265e2 100644
--- a/js/uv_coverage.js
+++ b/js/uv_coverage.js
@@ -53,12 +53,41 @@ class UVCoverageSimulator {
         // Dados UV armazenados
         this.uvData = null;
 
+        // WebGPU: tenta inicializar se disponível
+        this.gpuDevice = null;
+        this.gpuAvailable = false;
+        this._initWebGPU();
+
         this._initUI();
         this._bindEvents();
 
         console.log("UVCoverageSimulator: Módulo de cobertura UV inicializado.");
     }
 
+    /**
+     * Tenta inicializar WebGPU para aceleração de hardware.
+     * Se não disponível, usa CPU como fallback silencioso.
+     * @private
+     */
+    async _initWebGPU() {
+        try {
+            if (!navigator.gpu) {
+                console.log("UVCoverageSimulator: WebGPU não disponível, usando CPU.");
+                return;
+            }
+            const adapter = await navigator.gpu.requestAdapter();
+            if (!adapter) {
+                console.log("UVCoverageSimulator: WebGPU adapter não encontrado, usando CPU.");
+                return;
+            }
+            this.gpuDevice = await adapter.requestDevice();
+            this.gpuAvailable = true;
+            console.log("UVCoverageSimulator: WebGPU inicializado com sucesso — aceleração de hardware ativa.");
+        } catch (err) {
+            console.log("UVCoverageSimulator: WebGPU falhou, usando CPU:", err.message);
+        }
+    }
+
     /**
      * Inicializa valores padrão nos campos da UI.
      * @private
@@ -133,7 +162,7 @@ class UVCoverageSimulator {
 
     /**
      * Calcula a cobertura UV para todos os pares de estações e passos de tempo.
-     * Para cada baseline, calcula u,v como função do ângulo horário.
+     * Tenta usar WebGPU se disponível para aceleração; caso contrário, usa CPU.
      *
      * u = Bx*sin(H) + By*cos(H)
      * v = -Bx*sin(dec)*cos(H) + By*sin(dec)*sin(H) + Bz*cos(dec)
@@ -141,7 +170,7 @@ class UVCoverageSimulator {
      * Bx, By são componentes do baseline no plano local (Bz = 0 para estações coplanares).
      * Coordenadas em comprimentos de onda: u_λ = u/λ, v_λ = v/λ.
      */
-    generateUVCoverage() {
+    async generateUVCoverage() {
         const stations = this.getStationPositions();
         if (!stations || stations.length < 2) {
             this.updateStatus("Erro: São necessárias pelo menos 2 estações para calcular a cobertura UV.");
@@ -153,37 +182,61 @@ class UVCoverageSimulator {
 
         const params = this._readParams();
         const decRad = params.dec * BingoConstants.DEG_TO_RAD;
-        const latRad = params.latitude * BingoConstants.DEG_TO_RAD;
         const lambda = BingoConstants.SPEED_OF_LIGHT / params.freqHz;
-
         const sinDec = Math.sin(decRad);
         const cosDec = Math.cos(decRad);
-        const sinLat = Math.sin(latRad);
-        const cosLat = Math.cos(latRad);
 
         // Ângulos horários: centrados em 0, de -duration/2 a +duration/2
         const halfDuration = params.duration / 2;
         const hourAngles = [];
         for (let i = 0; i < params.timesteps; i++) {
             const hHours = params.timesteps === 1 ? 0 : -halfDuration + (params.duration * i) / (params.timesteps - 1);
-            // Converter horas para radianos (1h = 15°)
             hourAngles.push(hHours * 15 * BingoConstants.DEG_TO_RAD);
         }
 
+        let uvResult;
+
+        // Tenta usar WebGPU para cálculos massivos
+        if (this.gpuAvailable && this.gpuDevice && stations.length >= 10) {
+            try {
+                this.updateStatus("Calculando cobertura UV (WebGPU)...");
+                uvResult = await this._computeUVonGPU(stations, hourAngles, sinDec, cosDec, lambda);
+                this.updateStatus(`Cobertura UV gerada via GPU: ${uvResult.nBaselines} baselines, ${uvResult.uPoints.length} pontos.`);
+            } catch (gpuErr) {
+                console.warn("UVCoverageSimulator: WebGPU falhou, usando CPU:", gpuErr.message);
+                uvResult = this._computeUVonCPU(stations, hourAngles, sinDec, cosDec, lambda);
+            }
+        } else {
+            uvResult = this._computeUVonCPU(stations, hourAngles, sinDec, cosDec, lambda);
+        }
+
+        this.uvData = { ...uvResult, lambda, params };
+
+        const accel = (this.gpuAvailable && stations.length >= 10) ? 'GPU' : 'CPU';
+        console.log(`UVCoverageSimulator [${accel}]: ${uvResult.nBaselines} baselines, ${uvResult.uPoints.length} pontos UV.`);
+
+        this.plotUVCoverage(this.uvData);
+        this.calculateResolution();
+        if (!this.uvData._statusSet) {
+            this.updateStatus(`Cobertura UV gerada (${accel}): ${uvResult.nBaselines} baselines, ${uvResult.uPoints.length} pontos.`);
+        }
+    }
+
+    /**
+     * Calcula UV coverage na CPU (fallback padrão).
+     * @private
+     */
+    _computeUVonCPU(stations, hourAngles, sinDec, cosDec, lambda) {
         const uPoints = [];
         const vPoints = [];
         const baselineLengths = [];
         let maxBaseline = 0;
-
         const nStations = stations.length;
 
         for (let i = 0; i < nStations; i++) {
             for (let j = i + 1; j < nStations; j++) {
-                // Componentes do baseline no plano local (ENU: East, North, Up)
-                const Bx = stations[j].x - stations[i].x; // East
-                const By = stations[j].y - stations[i].y; // North
-                const Bz = 0; // Estações coplanares
-
+                const Bx = stations[j].x - stations[i].x;
+                const By = stations[j].y - stations[i].y;
                 const bLen = Math.sqrt(Bx * Bx + By * By);
                 if (bLen > maxBaseline) maxBaseline = bLen;
 
@@ -193,17 +246,15 @@ class UVCoverageSimulator {
                     const cosH = Math.cos(H);
 
                     const u = Bx * sinH + By * cosH;
-                    const v = -Bx * sinDec * cosH + By * sinDec * sinH + Bz * cosDec;
+                    const v = -Bx * sinDec * cosH + By * sinDec * sinH;
 
                     const uLambda = u / lambda;
                     const vLambda = v / lambda;
 
-                    // Ponto original
                     uPoints.push(uLambda);
                     vPoints.push(vLambda);
                     baselineLengths.push(bLen);
 
-                    // Ponto conjugado (-u, -v)
                     uPoints.push(-uLambda);
                     vPoints.push(-vLambda);
                     baselineLengths.push(bLen);
@@ -211,14 +262,187 @@ class UVCoverageSimulator {
             }
         }
 
-        this.uvData = { uPoints, vPoints, baselineLengths, maxBaseline, lambda, params };
+        const nBaselines = (nStations * (nStations - 1)) / 2;
+        return { uPoints, vPoints, baselineLengths, maxBaseline, nBaselines };
+    }
 
+    /**
+     * Calcula UV coverage usando WebGPU compute shader.
+     * @private
+     */
+    async _computeUVonGPU(stations, hourAngles, sinDec, cosDec, lambda) {
+        const device = this.gpuDevice;
+        const nStations = stations.length;
         const nBaselines = (nStations * (nStations - 1)) / 2;
-        console.log(`UVCoverageSimulator: ${nBaselines} baselines calculadas, ${uPoints.length} pontos UV gerados.`);
+        const nTimesteps = hourAngles.length;
+        const nOutputPoints = nBaselines * nTimesteps * 2; // ×2 for conjugate
 
-        this.plotUVCoverage(this.uvData);
-        this.calculateResolution();
-        this.updateStatus(`Cobertura UV gerada: ${nBaselines} baselines, ${uPoints.length} pontos.`);
+        // Prepare baseline pairs and hour angles
+        const baselinePairs = new Float32Array(nBaselines * 2); // Bx, By per pair
+        let bIdx = 0;
+        for (let i = 0; i < nStations; i++) {
+            for (let j = i + 1; j < nStations; j++) {
+                baselinePairs[bIdx++] = stations[j].x - stations[i].x;
+                baselinePairs[bIdx++] = stations[j].y - stations[i].y;
+            }
+        }
+
+        const hourAngleArray = new Float32Array(hourAngles);
+
+        // Uniform data: sinDec, cosDec, lambda, nTimesteps, nBaselines
+        const uniformData = new Float32Array([sinDec, cosDec, lambda, nTimesteps, nBaselines]);
+
+        // Create GPU buffers
+        const baselinesBuffer = device.createBuffer({
+            size: baselinePairs.byteLength,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+        });
+        device.queue.writeBuffer(baselinesBuffer, 0, baselinePairs);
+
+        const hourAnglesBuffer = device.createBuffer({
+            size: hourAngleArray.byteLength,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+        });
+        device.queue.writeBuffer(hourAnglesBuffer, 0, hourAngleArray);
+
+        const uniformBuffer = device.createBuffer({
+            size: uniformData.byteLength,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        });
+        device.queue.writeBuffer(uniformBuffer, 0, uniformData);
+
+        // Output: u, v, baselineLength per point (×2 for conjugate)
+        const outputSize = nOutputPoints * 3 * 4; // 3 floats × 4 bytes each
+        const outputBuffer = device.createBuffer({
+            size: outputSize,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+        });
+
+        const readBuffer = device.createBuffer({
+            size: outputSize,
+            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+        });
+
+        // WGSL shader
+        const shaderCode = `
+            struct Uniforms {
+                sinDec: f32,
+                cosDec: f32,
+                lambda: f32,
+                nTimesteps: f32,
+                nBaselines: f32,
+            };
+
+            @group(0) @binding(0) var<storage, read> baselines: array<f32>;
+            @group(0) @binding(1) var<storage, read> hourAngles: array<f32>;
+            @group(0) @binding(2) var<uniform> uniforms: Uniforms;
+            @group(0) @binding(3) var<storage, read_write> output: array<f32>;
+
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+                let nTimesteps = u32(uniforms.nTimesteps);
+                let nBaselines = u32(uniforms.nBaselines);
+                let totalWork = nBaselines * nTimesteps;
+                let idx = gid.x;
+                if (idx >= totalWork) { return; }
+
+                let bIdx = idx / nTimesteps;
+                let tIdx = idx % nTimesteps;
+
+                let Bx = baselines[bIdx * 2u];
+                let By = baselines[bIdx * 2u + 1u];
+                let bLen = sqrt(Bx * Bx + By * By);
+
+                let H = hourAngles[tIdx];
+                let sinH = sin(H);
+                let cosH = cos(H);
+
+                let u = Bx * sinH + By * cosH;
+                let v = -Bx * uniforms.sinDec * cosH + By * uniforms.sinDec * sinH;
+
+                let uLam = u / uniforms.lambda;
+                let vLam = v / uniforms.lambda;
+
+                // Original point
+                let outIdx = idx * 6u; // 2 points × 3 values
+                output[outIdx] = uLam;
+                output[outIdx + 1u] = vLam;
+                output[outIdx + 2u] = bLen;
+
+                // Conjugate point
+                output[outIdx + 3u] = -uLam;
+                output[outIdx + 4u] = -vLam;
+                output[outIdx + 5u] = bLen;
+            }
+        `;
+
+        const shaderModule = device.createShaderModule({ code: shaderCode });
+
+        const bindGroupLayout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+                { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+                { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform' } },
+                { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } }
+            ]
+        });
+
+        const pipeline = device.createComputePipeline({
+            layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+            compute: { module: shaderModule, entryPoint: 'main' }
+        });
+
+        const bindGroup = device.createBindGroup({
+            layout: bindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer: baselinesBuffer } },
+                { binding: 1, resource: { buffer: hourAnglesBuffer } },
+                { binding: 2, resource: { buffer: uniformBuffer } },
+                { binding: 3, resource: { buffer: outputBuffer } }
+            ]
+        });
+
+        const totalWork = nBaselines * nTimesteps;
+        const workgroupSize = 64;
+        const numWorkgroups = Math.ceil(totalWork / workgroupSize);
+
+        const commandEncoder = device.createCommandEncoder();
+        const pass = commandEncoder.beginComputePass();
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bindGroup);
+        pass.dispatchWorkgroups(numWorkgroups);
+        pass.end();
+
+        commandEncoder.copyBufferToBuffer(outputBuffer, 0, readBuffer, 0, outputSize);
+        device.queue.submit([commandEncoder.finish()]);
+
+        await readBuffer.mapAsync(GPUMapMode.READ);
+        const resultData = new Float32Array(readBuffer.getMappedRange().slice(0));
+        readBuffer.unmap();
+
+        // Parse output
+        const uPoints = [];
+        const vPoints = [];
+        const baselineLengths = [];
+        let maxBaseline = 0;
+
+        for (let i = 0; i < nOutputPoints; i++) {
+            const offset = i * 3;
+            uPoints.push(resultData[offset]);
+            vPoints.push(resultData[offset + 1]);
+            const bLen = resultData[offset + 2];
+            baselineLengths.push(bLen);
+            if (bLen > maxBaseline) maxBaseline = bLen;
+        }
+
+        // Cleanup GPU buffers
+        baselinesBuffer.destroy();
+        hourAnglesBuffer.destroy();
+        uniformBuffer.destroy();
+        outputBuffer.destroy();
+        readBuffer.destroy();
+
+        return { uPoints, vPoints, baselineLengths, maxBaseline, nBaselines };
     }
 
     /**

From 67e0e2d4050894bb8803eabbedde60b1e3b5596a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 03:35:22 +0000
Subject: [PATCH 20/22] Address code review: add GPU_MIN_STATIONS constant,
 await GPU init, move CSS, add paste feedback, fix redundancies

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css      | 11 +++++++++++
 js/ini_generator.js |  3 +++
 js/map.js           |  7 +------
 js/stations.js      | 15 ++++++++++-----
 js/uv_coverage.js   | 17 ++++++++++++++---
 5 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index d108b9b..be865ef 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -587,6 +587,17 @@ button.small-btn {
     width: 100%; box-sizing: border-box;
 }
 .map-container h2 { margin-bottom: 15px; text-align: center; }
+.map-scroll-overlay {
+    position: absolute;
+    top: 0; left: 0; width: 100%; height: 100%;
+    display: flex; align-items: center; justify-content: center;
+    background: rgba(0,0,0,0.5);
+    color: #fff; font-size: 16px; font-weight: 600;
+    z-index: 1000; pointer-events: none;
+    opacity: 0; transition: opacity 0.3s;
+    text-shadow: 0 1px 3px rgba(0,0,0,0.8);
+    border-radius: 8px;
+}
 .map-content { display: flex; flex-wrap: wrap; gap: 20px; }
 .map {
     height: 550px; 
diff --git a/js/ini_generator.js b/js/ini_generator.js
index efb48ce..31be987 100644
--- a/js/ini_generator.js
+++ b/js/ini_generator.js
@@ -1022,6 +1022,7 @@ class OskarIniGenerator {
                     // Fallback: foca e seleciona o campo para o usuário colar manualmente
                     input.focus();
                     input.select();
+                    input.placeholder = '⚠ Use Ctrl+V para colar o caminho aqui';
                 }
             });
 
@@ -2004,6 +2005,7 @@ class OskarImagerGenerator {
                 } catch (_err) {
                     input.focus();
                     input.select();
+                    input.placeholder = '⚠ Use Ctrl+V para colar o caminho aqui';
                 }
             });
 
@@ -3149,6 +3151,7 @@ class OskarBeamPatternGenerator {
                 } catch (_err) {
                     input.focus();
                     input.select();
+                    input.placeholder = '⚠ Use Ctrl+V para colar o caminho aqui';
                 }
             });
 
diff --git a/js/map.js b/js/map.js
index 7a8513d..e787bf5 100644
--- a/js/map.js
+++ b/js/map.js
@@ -242,15 +242,10 @@ class InteractiveMap {
     _setupCtrlScrollZoom() {
         const mapContainer = this.map.getContainer();
 
-        // Cria overlay de mensagem
+        // Cria overlay de mensagem (CSS no stylesheet: .map-scroll-overlay)
         const overlay = document.createElement('div');
         overlay.className = 'map-scroll-overlay';
         overlay.textContent = 'Use Ctrl + scroll para dar zoom no mapa';
-        overlay.style.cssText = 'position:absolute;top:0;left:0;width:100%;height:100%;' +
-            'display:flex;align-items:center;justify-content:center;' +
-            'background:rgba(0,0,0,0.5);color:#fff;font-size:16px;font-weight:600;' +
-            'z-index:1000;pointer-events:none;opacity:0;transition:opacity 0.3s;' +
-            'text-shadow:0 1px 3px rgba(0,0,0,0.8);border-radius:8px;';
         mapContainer.style.position = 'relative';
         mapContainer.appendChild(overlay);
 
diff --git a/js/stations.js b/js/stations.js
index 0bca430..1998186 100644
--- a/js/stations.js
+++ b/js/stations.js
@@ -60,6 +60,12 @@ const SHORT_BASELINE_THRESHOLD = 50;
  */
 const LONG_BASELINE_THRESHOLD = 1000;
 
+/**
+ * Ângulo dourado (radianos) para padrão girassol/Fibonacci: π(3 - √5) ≈ 137.508°.
+ * @constant {number}
+ */
+const GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
+
 class StationManager {
     constructor() {
         // IDs dos elementos da UI
@@ -455,8 +461,8 @@ class StationManager {
         for (let r = 0; r < rows && positions.length < count; r++) {
             for (let c = 0; c < cols && positions.length < count; c++) {
                 // Espaçamento exponencial: distância cresce com o índice
-                const xSpacing = spacing * sx * Math.pow(c + 1, expGrowth) / Math.pow(1, expGrowth);
-                const ySpacing = spacing * sy * Math.pow(r + 1, expGrowth) / Math.pow(1, expGrowth);
+                const xSpacing = spacing * sx * Math.pow(c + 1, expGrowth);
+                const ySpacing = spacing * sy * Math.pow(r + 1, expGrowth);
                 let x = (expGrowth === 1.0) ? c * spacing * sx : xSpacing - spacing * sx;
                 let y = (expGrowth === 1.0) ? r * spacing * sy : ySpacing - spacing * sy;
                 if (jitter > 0) {
@@ -694,7 +700,7 @@ class StationManager {
                     const r = area * Math.sqrt(rng());
                     const theta = 2 * Math.PI * rng();
                     x = r * Math.cos(theta);
-                    y = r * 0.6 * Math.sin(theta);
+                    y = r * sigma * Math.sin(theta); // sigma como razão de eixos
                 } else {
                     x = (rng() - 0.5) * 2 * area;
                     y = (rng() - 0.5) * 2 * area;
@@ -771,13 +777,12 @@ class StationManager {
         const offsetDeg = this._getExtraParam('sp-sun-offset', 0);
         const radialExp = this._getExtraParam('sp-sun-exp', 0.5);
         const offsetRad = offsetDeg * Math.PI / 180;
-        const goldenAngle = Math.PI * (3 - Math.sqrt(5)); // ~137.508°
 
         const positions = [];
         for (let i = 0; i < count; i++) {
             const n = i + alpha;
             const r = spacing * Math.pow(n / count, radialExp);
-            const theta = i * goldenAngle + offsetRad;
+            const theta = i * GOLDEN_ANGLE + offsetRad;
             positions.push({ x: r * Math.cos(theta), y: r * Math.sin(theta) });
         }
         return positions;
diff --git a/js/uv_coverage.js b/js/uv_coverage.js
index da265e2..389adbf 100644
--- a/js/uv_coverage.js
+++ b/js/uv_coverage.js
@@ -17,6 +17,9 @@
 
 'use strict';
 
+/** Número mínimo de estações para usar aceleração via WebGPU. */
+const GPU_MIN_STATIONS_THRESHOLD = 10;
+
 class UVCoverageSimulator {
     constructor() {
         // IDs dos elementos da UI
@@ -56,7 +59,7 @@ class UVCoverageSimulator {
         // WebGPU: tenta inicializar se disponível
         this.gpuDevice = null;
         this.gpuAvailable = false;
-        this._initWebGPU();
+        this._gpuReadyPromise = this._initWebGPU();
 
         this._initUI();
         this._bindEvents();
@@ -67,7 +70,9 @@ class UVCoverageSimulator {
     /**
      * Tenta inicializar WebGPU para aceleração de hardware.
      * Se não disponível, usa CPU como fallback silencioso.
+     * Retorna uma promise que resolve quando a verificação é concluída.
      * @private
+     * @returns {Promise<void>}
      */
     async _initWebGPU() {
         try {
@@ -180,6 +185,11 @@ class UVCoverageSimulator {
 
         this.updateStatus("Calculando cobertura UV...");
 
+        // Aguarda WebGPU ficar pronto (se ainda estiver inicializando)
+        if (this._gpuReadyPromise) {
+            await this._gpuReadyPromise;
+        }
+
         const params = this._readParams();
         const decRad = params.dec * BingoConstants.DEG_TO_RAD;
         const lambda = BingoConstants.SPEED_OF_LIGHT / params.freqHz;
@@ -197,7 +207,7 @@ class UVCoverageSimulator {
         let uvResult;
 
         // Tenta usar WebGPU para cálculos massivos
-        if (this.gpuAvailable && this.gpuDevice && stations.length >= 10) {
+        if (this.gpuAvailable && this.gpuDevice && stations.length >= GPU_MIN_STATIONS_THRESHOLD) {
             try {
                 this.updateStatus("Calculando cobertura UV (WebGPU)...");
                 uvResult = await this._computeUVonGPU(stations, hourAngles, sinDec, cosDec, lambda);
@@ -212,7 +222,7 @@ class UVCoverageSimulator {
 
         this.uvData = { ...uvResult, lambda, params };
 
-        const accel = (this.gpuAvailable && stations.length >= 10) ? 'GPU' : 'CPU';
+        const accel = (this.gpuAvailable && stations.length >= GPU_MIN_STATIONS_THRESHOLD) ? 'GPU' : 'CPU';
         console.log(`UVCoverageSimulator [${accel}]: ${uvResult.nBaselines} baselines, ${uvResult.uPoints.length} pontos UV.`);
 
         this.plotUVCoverage(this.uvData);
@@ -417,6 +427,7 @@ class UVCoverageSimulator {
         device.queue.submit([commandEncoder.finish()]);
 
         await readBuffer.mapAsync(GPUMapMode.READ);
+        // slice(0) is required: getMappedRange() returns a buffer that is detached after unmap()
         const resultData = new Float32Array(readBuffer.getMappedRange().slice(0));
         readBuffer.unmap();
 

From 2a5585624201bc6dd53b58018091694dbfa1448d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 04:04:37 +0000
Subject: [PATCH 21/22] Add real-time station generation on parameter change
 and coordinate format selector (ECEF/ENU)

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 css/styles.css | 13 +++++++++++++
 index.html     | 34 +++++++++++++++++++++++++++-------
 js/export.js   | 11 +++++++++++
 js/stations.js | 35 +++++++++++++++++++++++++++++++++--
 4 files changed, 84 insertions(+), 9 deletions(-)

diff --git a/css/styles.css b/css/styles.css
index be865ef..be10123 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -641,6 +641,19 @@ button.small-btn {
 .download-zip-group input[type="text"] { padding: 9px; border: 1px solid var(--border-color); border-radius: 4px; font-size: 14px; background-color: var(--input-bg-color); color: var(--input-text-color); flex-grow: 1; min-width: 200px; max-width: 400px; }
 .export-container p small { display: block; text-align: center; margin-top: 15px; }
 
+/* Seletor de formato de coordenadas (ECEF / ENU) */
+.coord-format-section { grid-column: 1 / -1; }
+.coord-format-header { display: flex; align-items: center; gap: 6px; margin-bottom: 8px; font-weight: 500; }
+.coord-format-title { font-size: 14px; }
+.coord-help-icon { cursor: help; font-size: 16px; color: var(--primary-color); opacity: 0.8; }
+.coord-help-icon:hover { opacity: 1; }
+.coord-format-selector { display: flex; gap: 16px; margin-bottom: 10px; }
+.coord-radio-label { display: flex; align-items: center; gap: 4px; cursor: pointer; font-weight: 500; font-size: 13px; }
+.coord-radio-label input[type="radio"] { accent-color: var(--primary-color); }
+.coord-format-panel { position: relative; }
+.coord-format-panel label { display: block; margin-bottom: 5px; font-weight: 500; }
+.coord-format-panel textarea { width: 100%; height: 180px; padding: 10px; padding-right: 35px; border: 1px solid var(--border-color); border-radius: 4px; font-family: monospace; font-size: 12px; resize: vertical; background-color: var(--input-bg-color); color: var(--input-text-color); box-sizing: border-box; }
+
 /* Estilos comuns (formulários, botões, sliders) */
 .form-group { margin-bottom: 15px; }
 .form-group label { display: block; margin-bottom: 5px; font-weight: 500; }
diff --git a/index.html b/index.html
index cf9ed01..0924c47 100644
--- a/index.html
+++ b/index.html
@@ -445,13 +445,33 @@ <h2 id="export-heading">Exportação (Estrutura OSKAR)</h2>
                     <label for="export-tile-layout">station/tile/layout.txt:</label>
                     <textarea id="export-tile-layout" readonly title="Coordenadas XY relativas das 64 antenas no tile"></textarea>
                 </div>
-                 <div class="export-field">
-                    <label for="export-layout-ecef">layout_ecef.txt:</label>
-                    <textarea id="export-layout-ecef" readonly title="Coordenadas ECEF (Earth-Centered Earth-Fixed) das estações"></textarea>
-                </div>
-                 <div class="export-field">
-                    <label for="export-layout-enu">layout_enu.txt:</label>
-                    <textarea id="export-layout-enu" readonly title="Coordenadas ENU (East-North-Up) relativas ao BINGO Central"></textarea>
+
+                <!-- Seletor de formato de coordenadas (ECEF vs ENU) -->
+                <div class="export-field coord-format-section">
+                    <div class="coord-format-header">
+                        <span class="coord-format-title">Formato alternativo de coordenadas:</span>
+                        <span class="coord-help-icon" title="WGS84 (acima) é o formato padrão (lat,lon,alt). Aqui você pode escolher um formato alternativo para incluir na exportação.">&#9432;</span>
+                    </div>
+                    <div class="coord-format-selector" role="radiogroup" aria-label="Formato de coordenadas">
+                        <label class="coord-radio-label">
+                            <input type="radio" name="coord-format" value="ecef" checked>
+                            <span>ECEF</span>
+                            <span class="coord-help-icon" title="ECEF (Earth-Centered Earth-Fixed): Coordenadas cartesianas geocêntricas (X,Y,Z em metros) com origem no centro da Terra. Usado pelo OSKAR para definir posições absolutas das estações no espaço 3D. Ideal quando se precisa de precisão absoluta na geometria do arranjo.">&#9432;</span>
+                        </label>
+                        <label class="coord-radio-label">
+                            <input type="radio" name="coord-format" value="enu">
+                            <span>ENU</span>
+                            <span class="coord-help-icon" title="ENU (East-North-Up): Coordenadas locais topocêntricas (Leste,Norte,Cima em metros) relativas ao centro do BINGO. Usado pelo OSKAR como sistema de referência local para layouts de estações. Ideal para visualizar e editar distâncias relativas entre estações.">&#9432;</span>
+                        </label>
+                    </div>
+                    <div id="coord-format-ecef" class="coord-format-panel">
+                        <label for="export-layout-ecef">layout_ecef.txt:</label>
+                        <textarea id="export-layout-ecef" readonly title="Coordenadas ECEF (Earth-Centered Earth-Fixed) das estações"></textarea>
+                    </div>
+                    <div id="coord-format-enu" class="coord-format-panel" style="display:none;">
+                        <label for="export-layout-enu">layout_enu.txt:</label>
+                        <textarea id="export-layout-enu" readonly title="Coordenadas ENU (East-North-Up) relativas ao BINGO Central"></textarea>
+                    </div>
                 </div>
             </div>
             <div class="download-zip-group">
diff --git a/js/export.js b/js/export.js
index 745b14f..66b525c 100644
--- a/js/export.js
+++ b/js/export.js
@@ -427,6 +427,17 @@ document.addEventListener('DOMContentLoaded', () => {
         }
     };
 
+    // --- Seletor de formato de coordenadas (ECEF / ENU) ---
+    const coordRadios = document.querySelectorAll('input[name="coord-format"]');
+    const ecefPanel = document.getElementById('coord-format-ecef');
+    const enuPanel = document.getElementById('coord-format-enu');
+    coordRadios.forEach(radio => {
+        radio.addEventListener('change', () => {
+            if (ecefPanel) ecefPanel.style.display = radio.value === 'ecef' ? '' : 'none';
+            if (enuPanel) enuPanel.style.display = radio.value === 'enu' ? '' : 'none';
+        });
+    });
+
     // --- Lógica para o Botão de Download ZIP ---
     const downloadBtn = document.getElementById('download-zip-btn');
     const filenameInput = document.getElementById('zip-filename-input');
diff --git a/js/stations.js b/js/stations.js
index 1998186..736b312 100644
--- a/js/stations.js
+++ b/js/stations.js
@@ -113,6 +113,9 @@ class StationManager {
         this.baselineInfo = document.getElementById(this.baselineInfoId);
         this.extraParamsContainer = document.getElementById(this.extraParamsContainerId);
 
+        // Timer para debounce da geração automática
+        this._autoGenTimer = null;
+
         if (!this.generateBtn && !this.layoutTypeSelect) {
             console.warn("StationManager: Elementos DOM de estações não encontrados. Módulo em modo stand-by.");
             return;
@@ -131,17 +134,36 @@ class StationManager {
             });
         }
         if (this.spacingRange) {
-            this.spacingRange.addEventListener('input', () => this._updateSpacingDisplay());
+            this.spacingRange.addEventListener('input', () => {
+                this._updateSpacingDisplay();
+                this._autoGenerate();
+            });
+        }
+        if (this.stationCountInput) {
+            this.stationCountInput.addEventListener('input', () => this._autoGenerate());
         }
         if (this.layoutTypeSelect) {
-            this.layoutTypeSelect.addEventListener('change', () => this._updateExtraParams());
+            this.layoutTypeSelect.addEventListener('change', () => {
+                this._updateExtraParams();
+                this._autoGenerate();
+            });
         }
 
         this._updateSpacingDisplay();
         this._updateExtraParams();
+        // Geração inicial automática
+        this.generateStations();
         console.log("StationManager: Módulo de estações inicializado.");
     }
 
+    /**
+     * Gera estações automaticamente com debounce (150ms) ao alterar qualquer parâmetro.
+     */
+    _autoGenerate() {
+        clearTimeout(this._autoGenTimer);
+        this._autoGenTimer = setTimeout(() => this.generateStations(), 150);
+    }
+
     /**
      * Converte o valor linear do range input para escala logarítmica.
      * @returns {number} Espaçamento em metros (escala log).
@@ -282,6 +304,15 @@ class StationManager {
             }
         }
         this.extraParamsContainer.innerHTML = html;
+
+        // Vincula listeners nos novos parâmetros dinâmicos para geração automática
+        const defs2 = paramDefs[layout] || [];
+        for (const p of defs2) {
+            const el = document.getElementById(p.id);
+            if (el) {
+                el.addEventListener(p.type === 'select' ? 'change' : 'input', () => this._autoGenerate());
+            }
+        }
     }
 
     /**

From 505c4990fc10be2c5bc70781aadf6966065b68ef Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 04:07:55 +0000
Subject: [PATCH 22/22] Address code review: reuse existing defs variable in
 _updateExtraParams listener binding

Co-authored-by: Geovannisz <82838501+Geovannisz@users.noreply.github.com>
---
 js/stations.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/js/stations.js b/js/stations.js
index 736b312..b5aaf64 100644
--- a/js/stations.js
+++ b/js/stations.js
@@ -306,8 +306,7 @@ class StationManager {
         this.extraParamsContainer.innerHTML = html;
 
         // Vincula listeners nos novos parâmetros dinâmicos para geração automática
-        const defs2 = paramDefs[layout] || [];
-        for (const p of defs2) {
+        for (const p of defs) {
             const el = document.getElementById(p.id);
             if (el) {
                 el.addEventListener(p.type === 'select' ? 'change' : 'input', () => this._autoGenerate());