using AgroBase.Models;
using AgroBase.Models.Modules;
using AgroBase.Models.Operadores;
using AgroBase.Properties;
using AgroBase.Services;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AgroBase.Forms.Operacoes
{
    public partial class frmResultadosOperacao : Form
    {
        List<OperacaoSensoriamentoLogModel> LogsOperacao = new List<OperacaoSensoriamentoLogModel>();
        List<DirSensoriamentoLogModel> LogsDirecional = new List<DirSensoriamentoLogModel>();
        List<MovSensoriamentoLogModel> LogsMovimentacao = new List<MovSensoriamentoLogModel>();
        List<AtuSensoriamentoLogModel> LogsAtuador = new List<AtuSensoriamentoLogModel>();
        List<SensoriamentoMensagemJsonModel> LogsSensoriamento = new List<SensoriamentoMensagemJsonModel>();
        List<List<CameraWorkerItemModel>> LogsCam_Solo = new List<List<CameraWorkerItemModel>>();
        List<string> pathImagensSolo = new List<string>();
        List<PictureBox> picsCamSolo = new List<PictureBox>();
        List<PictureBox> picsCamSoloSeg = new List<PictureBox>();
        List<PictureBox> picsCamSoloOverlay = new List<PictureBox>();
        List<CameraWorkerItemModel> LogsCam_Caminho = new List<CameraWorkerItemModel>();
        OperacaoModel operacaoSelecionada = new OperacaoModel(Enums.ModoOperacao.NaoDefinido);
        private readonly TopDownBboxView view_top_down = new TopDownBboxView();
        private readonly FrontalBboxView view_frontal = new FrontalBboxView();
        private readonly Bbox3DViewer view_3d = new Bbox3DViewer();
        string pathImagensCaminho = "";
        
        DateTime MomentoAtual = DateTime.Now;
        AsyncTaskTimerModel tmrPlay;
        MapasModel Mapa = new MapasModel();
        private Visualizador3DService visualizador3D;
        private MapaDinamicoModel MapaDinamico;
        private int idxMomentoAtual
        {
            get
            {
                return LogsOperacao.IndexOf(LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual));
            }
        }
        private int idxMomentoFiltro = 0;
        private List<int> idxValoresFiltro = new List<int>();

        private string[] cmbItemsBuscaPor = new string[] { "Pico Máximo", "Pico Mínimo" };

        GraficoInterativoModel graficoMovGeral;
        GraficoInterativoModel graficoMovTemperatura;
        GraficoInterativoModel graficoMovAlimentacao;
        GraficoInterativoModel graficoAtu;
        GraficoInterativoModel graficoSen;
        GraficoInterativoModel graficoCpu;
        GraficoInterativoModel graficoCameras;
        GraficoInterativoModel graficoErvas;


        public frmResultadosOperacao()
        {
            // Ativa o double buffering
            this.DoubleBuffered = true;
            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            this.SetStyle(ControlStyles.UserPaint, true);
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

            InitializeComponent();

            InitializeGLControl();
        }

        private void InitializeGLControl()
        {
            VersaoArquivoModel arquivo = VersionamentoService.ArquivoModelo3D("obj");

            visualizador3D = new Visualizador3DService();
            visualizador3D.InitializeGLControl(pnl3D, arquivo.CaminhoCompleto);
        }


        private void frmResultadosOperacao_Load(object sender, EventArgs e)
        {
            tmrPlay = new AsyncTaskTimerModel("tmrPlay", tmrPlay_Tick, 1000, this);

            picDIR_DF.Image = FuncoesGlobais.EspelharImagemHorizontalmente(Resources.roda_superior);
            picDIR_DT.Image = FuncoesGlobais.EspelharImagemHorizontalmente(Resources.roda_superior);

            MapaDinamico = new MapaDinamicoModel(this, pnlZoomMapa);

            view_top_down.Dock = DockStyle.Fill;
            view_top_down.PixelsPerMeter = 120f;        // ajuste fino da escala
            view_top_down.RangeForwardMeters = 12f;     // alcance pra frente
            view_top_down.RangeSideMeters = 4f;         // alcance lateral
            view_top_down.RangeBackwardMeters = 1.5f;   // alcance pra trás
            tabTopDown.Controls.Add(view_top_down);

            view_frontal.Dock = DockStyle.Fill;
            view_frontal.PixelsPerMeter = 120f;
            view_frontal.RangeSideMeters = 4f;
            view_frontal.RangeUpMeters = 3f;
            view_frontal.RangeDownMeters = 0.5f;
            view_frontal.DepthFade = true;   // esmaecer por distância X
            tabFrontal.Controls.Add(view_frontal);

            view_3d.Initialize(pnlTridimensional);
        }

        private async Task tmrPlay_Tick()
        {
            if (trbMomento.Value < trbMomento.Maximum)
            {
                trbMomento.Value++;
            }
            else
            {
                tmrPlay.Stop();
            }
        }

        private void trbMomento_ValueChanged(object sender, EventArgs e)
        {
            MomentoAtual = LogsOperacao.Skip(trbMomento.Value).FirstOrDefault().Momento;
            AtualizarDadosMomento();
        }

        private void btnPlay_Click(object sender, EventArgs e)
        {
            tmrPlay.Toogle();
            btnPlay.Text = tmrPlay.IsRunning ? "Pause" : "Pay";
        }

        private async void btnCarregarOperacao_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Filter = "Arquivos de Operação|*.lgop";
            ofd.InitialDirectory = Application.StartupPath + "\\" + Variaveis.CaminhoOperacoes;
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                OperacaoDadosModel data = JsonConvert.DeserializeObject<OperacaoDadosModel>(File.ReadAllText(ofd.FileName));

                LogsOperacao = JsonConvert.DeserializeObject<OperacaoSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.operacao)).ToList();

                GPSModel pos = GPSService.UltimaLeitura.Clone();
                GPSService.UltimaLeitura = LogsOperacao.FirstOrDefault().Gps;
                (bool sucesso, List<string> ruas) = Variaveis.OperacaoEmAndamento.CarregarParametrizacaoOperacao(null, null, ofd.FileName.Replace("data.lgop", "operacao.opr"));
                bool condicaoOperacaoCarregada() => Variaveis.OperacaoEmAndamento.Trajetoria?.CorredorAtual != null;
                bool resultado = await FuncoesGlobais.AguardarCondicaoAsync(condicaoOperacaoCarregada, 15000, 200);
                GPSService.UltimaLeitura = pos;

                LogsDirecional = JsonConvert.DeserializeObject<DirSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.dir ?? Enums.T_Code.Dir.ToString())).ToList();
                LogsMovimentacao = JsonConvert.DeserializeObject<MovSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.mov ?? Enums.T_Code.Mov.ToString())).ToList();
                LogsAtuador = JsonConvert.DeserializeObject<AtuSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.atu ?? Enums.T_Code.Atu.ToString())).ToList();
                LogsSensoriamento = JsonConvert.DeserializeObject<SensoriamentoMensagemJsonModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.sen ?? Enums.T_Code.Sen.ToString())).ToList();
                pathImagensCaminho = ofd.FileName.Replace("data.lgop", data.cam_caminho + "\\");
                LogsCam_Caminho = JsonConvert.DeserializeObject<List<CameraWorkerItemModel>>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.cam_caminho ?? Enums.T_Code.Snr.ToString())).ToList();

                pathImagensSolo = new List<string>();
                picsCamSolo = new List<PictureBox>();
                picsCamSoloSeg = new List<PictureBox>();
                picsCamSoloOverlay = new List<PictureBox>();
                flwCameras.Controls.Clear();
                LogsCam_Solo = new List<List<CameraWorkerItemModel>>();
                foreach (string cam in data.cam_solo)
                {
                    var log = JsonConvert.DeserializeObject<List<CameraWorkerItemModel>>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, cam)).ToList();
                    LogsCam_Solo.Add(log);
                    pathImagensSolo.Add(ofd.FileName.Replace("data.lgop", cam + "\\"));
                    PictureBox pic = new PictureBox()
                    {
                        Name = "picCamSolo_" + cam,
                        Width = 250,
                        Height = 166,
                        SizeMode = PictureBoxSizeMode.Zoom
                    };
                    PictureBox picSeg = new PictureBox()
                    {
                        Name = "picCamSoloSeg_" + cam,
                        Width = 250,
                        Height = 166,
                        SizeMode = PictureBoxSizeMode.Zoom
                    };
                    PictureBox picOverlay = new PictureBox()
                    {
                        Name = "picCamSoloOverlay_" + cam,
                        Width = 250,
                        Height = 166,
                        SizeMode = PictureBoxSizeMode.Zoom
                    };
                    flwCameras.Controls.Add(pic);
                    flwCameras.Controls.Add(picSeg);
                    flwCameras.Controls.Add(picOverlay);
                    picsCamSolo.Add(pic);
                    picsCamSoloSeg.Add(picSeg);
                    picsCamSoloOverlay.Add(picOverlay);
                }

                Mapa = new MapasModel()
                {
                    pnlMapa = pnlMapa
                };
                MapasService.CriarArquivoMapa(new List<List<GPSModel>>() { LogsOperacao.Select(x => x.Gps).ToList() }, 1517, data.id);
                Mapa.btnCarregar_Click(sender, e, Variaveis.CaminhoSistema + "/" + Variaveis.CaminhoMapasConvertidos + data.id + ".json");

                trbMomento.Maximum = LogsOperacao.Count - 1;
                trbMomento.Minimum = 0;
                trbMomento.Value = 0;

                MomentoAtual = LogsOperacao[0].Momento;

                this.Text = "Resultados da Operação " + LogsOperacao[0].Momento.ToString("dd/MM/yyyy");


                InicializarGraficos();
                InicializarCombosBusca();
                InicializarGridsComandos();


                AtualizarDadosMomento();

                //double distanciaOperacao = GPSUtils.DistanciaDoTrecho(LogsOperacao.Select(x => x.Gps).ToList());
                //Console.WriteLine($"Distancia Percorrida: {distanciaOperacao.ToString("0.00")} m");
            }
        }

        private void InicializarGraficos()
        {
            var Momentos = LogsOperacao.Select(x => x.Momento.ToString("mm:ss:fff")).ToList();

            graficoMovGeral = new GraficoInterativoModel(chartMovGeral, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "RPM SP", 
                    //Valores = LogsMovimentacao.GroupBy(x => new {ID = x.Modulo_ID, Momento = x.Momento}).Select(x => x.Average(y => y.RPM_SP)).ToList(), 
                    Valores = LogsOperacao.Select(x => (double)x.Controle.RPM_SP).ToList(), 
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
            });

            graficoMovTemperatura = new GraficoInterativoModel(chartMovTemperatura, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
            });

            graficoMovAlimentacao = new GraficoInterativoModel(chartMovTensao, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "W EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "W ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "W DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "W DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "% EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "% ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "% DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "% DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
            });

            graficoAtu = new GraficoInterativoModel(chartAtuador, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Pressão SP",
                    Valores = LogsAtuador.Select(x => x?.PressaoLinha_SP ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Pressão",
                    Valores = LogsAtuador.Select(x => x?.PressaoLinha ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Potência",
                    Valores = LogsAtuador.Select(x => x?.PotenciaBomba ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Volume",
                    Valores = LogsAtuador.Select(x => x?.VolumeReservatorio ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Reservatório",
                    Valores = LogsAtuador.Select(x => x?.PercentualReservatorio ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Vazão",
                    Valores = LogsAtuador.Select(x => x?.VazaoFluxoMLpSMedia ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                }
            });

            graficoSen = new GraficoInterativoModel(chartSensoriamento, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 3v3", 
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("3V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Tensao)?.atual?.valor) ?? 0).ToList(), 
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 3v3",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("3V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Corrente)?.atual?.valor) ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 5v0",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("5V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Tensao)?.atual?.valor) ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 5v0",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("5V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Corrente)?.atual?.valor) ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 7v2",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("7V2"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Tensao)?.atual?.valor) ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 7v2",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("7V2"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Corrente)?.atual?.valor) ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 12v",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("12V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Tensao)?.atual?.valor) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 12v",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("12V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Corrente)?.atual?.valor) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 24v",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("24V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Tensao)?.atual?.valor) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 24v",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("24V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Corrente)?.atual?.valor) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 36v",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("36V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Tensao)?.atual?.valor) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 36v",
                    Valores = LogsSensoriamento.Select(x => (double?)(x?.Sensores?.FirstOrDefault(y => y.ID.Contains("36V"))?.ValoresLeituras?.FirstOrDefault(z => z.funcao == FuncoesPinout.Corrente)?.atual?.valor) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V Bat",
                    Valores = LogsOperacao.Select(x => (double?)(x?.Bateria?.TensaoInstantanea) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A Bat",
                    Valores = LogsOperacao.Select(x => (double?)(x?.Bateria?.CorrenteInstantanea) ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
            });

            graficoCpu = new GraficoInterativoModel(chartCpu, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "CPU %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.CPU_load ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "GPU %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.GPU_load ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "HDD %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.HDD_load ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "RAM %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.RAM_usage ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "CPU Temp",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.CPU_temp ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "GPU Temp",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.GPU_temp ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Threads Ativas",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.ActiveThreads ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Threads de Trabalho %",
                    Valores = LogsOperacao.Select(x => (double)((x?.DadosPerformance.MaxWorkerThreads ?? 1) - (x?.DadosPerformance.WorkerThreads ?? 0)) / (x?.DadosPerformance.MaxWorkerThreads ?? 1) * 100.0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Threads de Portas %",
                    Valores = LogsOperacao.Select(x => (double)((x?.DadosPerformance.MaxCompletionPortThreads ?? 1) - (x?.DadosPerformance.CompletionPortThreads ?? 0)) / (x?.DadosPerformance.MaxCompletionPortThreads ?? 1) * 100.0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
            });

            // Obtemos todos os tipos de ervas identificadas ao longo dos logs
            /*var todasErvas = LogsOperacao
                .SelectMany(log => log.Atuador.ErvasIdentificadas)
                .SelectMany(bico => bico.Keys)
                .Distinct()
                .ToList();

            Dictionary<DateTime, Dictionary<string, int>> agrupamento = new Dictionary<DateTime, Dictionary<string, int>>();
            foreach (var log in LogsOperacao)
            {
                if (!agrupamento.Any(x => x.Key == log.Momento))
                {
                    agrupamento.Add(log.Momento, new Dictionary<string, int>());
                }
                foreach (var bico in log.Atuador.ErvasIdentificadas)
                {
                    if (bico.Any())
                    {
                        foreach (var erva in bico)
                        {
                            if (!agrupamento[log.Momento].ContainsKey(erva.Key))
                            {
                                agrupamento[log.Momento].Add(erva.Key, erva.Value);
                            }
                            else
                            {
                                agrupamento[log.Momento][erva.Key] += erva.Value;
                            }
                        }
                    }
                }
            }
            graficoErvas = new GraficoInterativoModel(chartErvas, Momentos, new List<GraficoInterativoSerieModel>(
                todasErvas
                    .Select(erva => new GraficoInterativoSerieModel
                    {
                        Titulo = erva,
                        Valores = LogsOperacao
                            .Select(log =>
                            {
                                if (agrupamento.ContainsKey(log.Momento) && agrupamento[log.Momento].ContainsKey(erva))
                                    return (double)agrupamento[log.Momento][erva];
                                else
                                    return 0.0; // Adiciona zero se a erva não foi detectada neste momento
                            })
                            .ToList(),
                        Visivel = true,
                        MostrarValor = true,
                        ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Pie
                    })
                    .ToList()
                )
            )
            {
                Titulo = "Ervas Identificadas"
            };*/

            List<GraficoInterativoSerieModel> seriesCamerasSolo = new List<GraficoInterativoSerieModel>();
            foreach (var camSolo in LogsCam_Solo)
            {
                string camNome = "Solo " + (LogsCam_Solo.IndexOf(camSolo) + 1);
                seriesCamerasSolo.AddRange(new List<GraficoInterativoSerieModel>()
                {
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} RAM %",
                        Valores = camSolo.Select(x => (double)(x?.performance?.memoria_usada ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} CPU Temp",
                        Valores = camSolo.Select(x => (double)(x?.performance?.temperatura ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                });
            }
            if (LogsCam_Caminho.Any(x => x.performance != null))
            {
                var camCaminho = LogsCam_Caminho;
                string camNome = "Caminho";
                seriesCamerasSolo.AddRange(new List<GraficoInterativoSerieModel>()
                {
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} RAM %",
                        Valores = camCaminho.Select(x => (double)(x?.performance?.memoria_usada ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} CPU Temp",
                        Valores = camCaminho.Select(x => (double)(x?.performance?.temperatura ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                });
            }
            graficoCameras = new GraficoInterativoModel(chartCameras, Momentos, seriesCamerasSolo);

        }

        private void InicializarGridsComandos()
        {
            dtComandosMov.Columns.Clear();
            dtComandosMov.Columns.Add("clDirecao", "Direção");
            dtComandosMov.Columns.Add("clRPMSP", "RPM SP");

            dtComandosDir.Columns.Clear();
            dtComandosDir.Columns.Add("clDirecao", "Direção");
            dtComandosDir.Columns.Add("clAnguloSP", "Angulo SP");
            dtComandosDir.Columns.Add("clTipoMovimento", "Tipo Movimento");

            dtComandosAtu.Columns.Clear();
            dtComandosAtu.Columns.Add("clB0", "B0");
            dtComandosAtu.Columns.Add("clB1", "B1");
            dtComandosAtu.Columns.Add("clB2", "B2");
            dtComandosAtu.Columns.Add("clB3", "B3");
        }

        private void InicializarCombosBusca()
        {
            CarregarInformacoesBusca(gpbMOV_Alimentacao_Filtro, graficoMovAlimentacao.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbMOV_Temperatura_Filtro, graficoMovTemperatura.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbMOV_Geral_Filtro, graficoMovGeral.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbSEN_Filtro, graficoSen.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbCpu_Filtro, graficoCpu.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbCameras_Filtro, graficoCameras.Series.Select(x => x.Titulo).ToArray());
        }

        private void CarregarInformacoesBusca(GroupBox gpb, string[] Componentes)
        {
            ComboBox cmbFiltro = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Filtro"));
            cmbFiltro.Items.Clear();
            cmbFiltro.Items.AddRange(cmbItemsBuscaPor);
            ComboBox cmbComponente = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Componente"));
            cmbComponente.Items.Clear();
            cmbComponente.Items.AddRange(Componentes);
            cmbComponente.SelectedIndexChanged += cmbComponente_SelectedIndexChanged;
            Button btnRedefinir = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Redefinir"));
            btnRedefinir.Click += btnRedefinirBusca_Click;
            Button btnBuscar = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Buscar"));
            btnBuscar.Click += btnBuscarMomento_Click;
            Button btnAnterior = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Anterior"));
            btnAnterior.Click += btnAnteriorFiltro_Click;
            Button btnProximo = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Proximo"));
            btnProximo.Click += btnProximoFiltro_Click; ;
        }

        private void btnAnteriorFiltro_Click(object sender, EventArgs e)
        {
            if (idxValoresFiltro.Any() && idxMomentoFiltro > 0)
            {
                idxMomentoFiltro--;
                trbMomento.Value = idxValoresFiltro[idxMomentoFiltro];
                AtualizarDadosMomento();
            }
        }

        private void btnProximoFiltro_Click(object sender, EventArgs e)
        {
            if (idxValoresFiltro.Any() && idxMomentoFiltro < idxValoresFiltro.Count() - 1)
            {
                idxMomentoFiltro++;
                trbMomento.Value = idxValoresFiltro[idxMomentoFiltro];
                AtualizarDadosMomento();
            }
        }

        private void cmbComponente_SelectedIndexChanged(object sender, EventArgs e)
        {
            AtualizarDadosMomento();
        }

        private void btnRedefinirBusca_Click(object sender, EventArgs e)
        {
            GroupBox gpb = (GroupBox)((Button)sender).Parent;
            ComboBox cmbFiltro = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Filtro"));
            cmbFiltro.SelectedIndex = -1;
            ComboBox cmbComponente = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Componente"));
            cmbComponente.SelectedIndex = -1;
            idxMomentoFiltro = 0;
            idxValoresFiltro = new List<int>();

            AtualizarDadosMomento();
        }

        private void btnBuscarMomento_Click(object sender, EventArgs e)
        {
            GroupBox gpb = (GroupBox)((Button)sender).Parent;
            ComboBox cmbFiltro = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Filtro"));
            if (cmbFiltro.SelectedIndex < 0)
            {
                return;
            }
            ComboBox cmbComponente = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Componente"));
            if (cmbComponente.SelectedIndex < 0)
            {
                return;
            }

            GraficoInterativoModel grafico = null;

            if (gpb.Name.Contains("SEN"))
            {
                grafico = graficoSen;
            }
            else if (gpb.Name.Contains("MOV_Temperatura"))
            {
                grafico = graficoMovTemperatura;
            }
            else if (gpb.Name.Contains("MOV_Alimentacao"))
            {
                grafico = graficoMovAlimentacao;
            }
            else if (gpb.Name.Contains("MOV_Geral"))
            {
                grafico = graficoMovGeral;
            }
            else if (gpb.Name.Contains("Cpu"))
            {
                grafico = graficoCpu;
            }
            else if (gpb.Name.Contains("Cameras"))
            {
                grafico = graficoCameras;
            }
            if (grafico != null)
            {
                var Dados = grafico.Series.FirstOrDefault(x => x.Titulo == cmbComponente.Text).Valores.Select((x, i) => new { valor = x, idx = i }).ToList();
                if (cmbFiltro.SelectedIndex == 0)
                {
                    Dados = Dados.OrderByDescending(x => x.valor).ToList();
                }
                else if (cmbFiltro.SelectedIndex == 1)
                {
                    Dados = Dados.OrderBy(x => x.valor).ToList();
                }

                idxValoresFiltro = Dados.Select(x => x.idx).ToList();
                idxMomentoFiltro = 0;

                trbMomento.Value = idxValoresFiltro[idxMomentoFiltro];
            }
        }

        private Bitmap CarregarImagemCamera(string Caminho, string complemento = "")
        {
            string caminhoCompleto = Caminho + trbMomento.Value + ".jpeg";
            if (!string.IsNullOrEmpty(complemento))
            {
                caminhoCompleto = caminhoCompleto.Replace(".jpeg", $"{complemento}.jpeg");
            }
            Bitmap frame = new Bitmap(1, 1);
            using (Graphics g = Graphics.FromImage(frame))
            {
                g.Clear(Color.Black);
            }
            Bitmap blackFrame = new Bitmap(frame);

            if (File.Exists(caminhoCompleto))
            {
                try
                {
                    return new Bitmap(Image.FromFile(caminhoCompleto));
                }
                catch (Exception ex)
                {

                }
            }

            return blackFrame;
        }

        private Bitmap DesenharDeteccoesErvas(WeedWorkerAnaliseModel frame, Bitmap bitmapOriginal)
        {
            // Criar um novo bitmap com base no original para desenhar por cima
            Bitmap bitmapComObjetos = new Bitmap(bitmapOriginal);

            // Pegar o gráfico do bitmap que será retornado
            using (Graphics g = Graphics.FromImage(bitmapComObjetos))
            {
                // Proporção de escala
                double scaleX = (double)bitmapComObjetos.Width / frame.width;
                double scaleY = (double)bitmapComObjetos.Height / frame.height;

                // Iterar sobre os objetos detectados
                /*foreach (var objeto in frame.deteccoes)
                {
                    // Ajustar coordenadas e tamanho de acordo com a escala
                    int xAtual = (int)(objeto.bbox[0] * scaleX);
                    int yAtual = (int)(objeto.bbox[1] * scaleY);
                    int larguraAtual = (int)(objeto.bbox[2] * scaleX);
                    int alturaAtual = (int)(objeto.bbox[3] * scaleY);

                    // Desenhar o retângulo ao redor do objeto
                    g.DrawRectangle(new Pen(Color.Red, 2), xAtual, yAtual, larguraAtual, alturaAtual);

                    // Desenhar a descrição do objeto (id: descricao)
                    string descricao = $"{objeto.descricao} | {objeto.confianca.ToString("0.00")} | ({objeto.id})";
                    g.DrawString(descricao, new Font("Arial", 20), Brushes.White, new PointF(xAtual, yAtual - 15));
                }*/
            }

            // Retornar o bitmap modificado
            return bitmapComObjetos;
        }

        private void AtualizarDadosMomento()
        {
            if (!LogsOperacao.Any())
            {
                return;
            }

            txtMomento.Text = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual).Momento.ToString("HH:mm:ss");

            AtualizarInformacoesOperacao();

            AtualizarInformacoesCameras();

            AtualizarInformacoesGPS();

            AtualizarInformacoesDirecional();

            AtualizarInformacoesMovimentacao();

            AtualizarInformacoesAtuador();

            AtualizarInformacoesSensoriamento();

            AtualizarInformacoesSonar();

            AtualizarInformacoesCPU();

            AtualizarInformacoesComandos();

            AtualizarInformacoesMPC();
        }

        private void AtualizarInformacoesOperacao()
        {
            var Log = LogsOperacao[idxMomentoAtual];
            var LogAtu = LogsAtuador[idxMomentoAtual];

            double herbicidaConsumido = Log.Atuador.HerbicidaConsumido != 0 ? Log.Atuador.HerbicidaConsumido : LogAtu.VolumeVazaoML;
            double percentualHerbicidaConsumido = FuncoesMatematicas.Clamp(((herbicidaConsumido / 1000.0) / LogsAtuador.FirstOrDefault().VolumeReservatorio) * 100.0, 0, 100);
            int totalAtuacoes = 0; // Log.Atuador.ErvasIdentificadas.Sum(dict => dict.Values.Sum());
            double herbicidaPorErva = Log.Atuador.HerbicidaPorErva != 0 ? Log.Atuador.HerbicidaPorErva : (herbicidaConsumido / (totalAtuacoes > 0 ? totalAtuacoes : 1));

            lblPercentualBateria.Text = $"Bateria {Log.Bateria.PercentualBateria.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualBateria, Log.Bateria.PercentualBateria);
            lblBateriaConsumida.Text = $"Consumido {Log.Bateria.PercentualBateriaConsumida.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualReservatorio, LogAtu.PercentualReservatorio);
            lblPercentualReservatorio.Text = $"Reservatório {LogAtu.PercentualReservatorio.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbHerbicidaConsumido, percentualHerbicidaConsumido);
            lblHerbicidaConsumido.Text = $"Consumido {herbicidaConsumido.ToString("0.00")} ml";
            FuncoesGlobais.PreencheValorProgressBar(pgbBateriaConsumida, Log.Bateria.PercentualBateriaConsumida);
            txtTempoMovimento.Text = FuncoesGlobais.ConverterSegundosParaHHmmss((int)Log.Movimentacao.TempoMovimentoSegs);
            txtStatusOperacao.Text = Log.StatusOperacao.ToString();
            txtStatusCarro.Text = $"{Log.Trajetoria.StatusCarro}";
            txtHerbicidaPorErva.Text = herbicidaPorErva.ToString("0.00") + " ml";
            txtDentroRua.Text = Log.Trajetoria.CorredorAtual.Dentro ? "Sim" : "Não";
            txtDirecaoCarro.Text = Log.Trajetoria.DirecaoCaminho.ToString() + " (" + Log.Trajetoria.CorredorAtual.Idx + " - " + Log.Trajetoria.ProximoPonto.idxPonto + " - " + Log.Trajetoria.ProximoPonto.idxPontoCorredor + ")";
            txtErvasNoRadar.Text = Log.Atuador.ErvasNoRadar.ToString() + " (" + (Log.Atuador.PercentualErvasNoRadar * 100).ToString("0.00") + "%)";
            txtErvasTerreno.Text = Log.Atuador.PercentualErvasTerreno.ToString("0.00");
            txtTipoMovimento.Text = Log.Controle.TipoMovimento.ToString();
            txtVelocidade.Text = (Log.Movimentacao.VelocidadeMedia * 3.6).ToString("0.00") + " km/h (" + Log.Movimentacao.VelocidadeMedia.ToString("0.00") + " m/s)";
            txtDirecaoControle.Text = (Log.Controle?.Direcao ?? Enums.Direcao.Parado).ToString() + " (" + (Log.Controle?.Latencia ?? 0).ToString("0.00") + " s)";
            txtVelocidadeControle.Text = ((Log.Controle?.PercentualVelocidadeSP ?? 0) / VariaveisEquipamento.RPM_Max_Roda * 100).ToString() + " rpm";
            txtErvasIdentificadas.Text = $"{totalAtuacoes}";

            txtDistanciasLaterais.Text = (Log.Trajetoria.DistanciaEsquerda * 100.0).ToString("0.00") + " cm / " + (Log.Trajetoria.DistanciaDireita * 100.0).ToString("0.00") + " cm";
            txtErroLateral.Text = (Log.Controle.ErroLateral * 100.0).ToString("0.00") + " cm";
            txtNaMargem.Text = Log.Trajetoria.NaMargemDoCorredor ? "Sim" : "Não";

            lblPercentualOperacao.Text = $"Operação {Log.Trajetoria.ProgressoTrajeto.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualOperacao, Log.Trajetoria.ProgressoTrajeto);

            double distanciaAtual = Log.Modo == Enums.ModoOperacao.MapaGPS ? Log.Trajetoria.DistanciaPercorrida : Log.Movimentacao.DistanciaPercorridaTotal;
            double distanciaTotal = Log.Modo == Enums.ModoOperacao.MapaGPS ? LogsOperacao[LogsOperacao.Count - 1].Trajetoria.DistanciaTotal : LogsOperacao[LogsOperacao.Count - 1].Movimentacao.DistanciaPercorridaTotal;
            txtDistanciaPercorrida.Text = distanciaAtual.ToString("0.00") + " m / " + distanciaTotal.ToString("0.00") + " m";

            double percentualRua = Log.Trajetoria.CorredorAtual.Progresso;
            lblPercentualRua.Text = $"Rua {percentualRua.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualRua, percentualRua);

            DateTime dataFim = Log.DataFim.Year != Log.DataInicio.Year ? LogsOperacao[LogsOperacao.Count - 1].Momento : Log.DataFim;
            txtDuracaoOperacao.Text = Log.TempoDecorrido.ToString("HH:mm:ss") + " / " + new DateTime().AddSeconds((dataFim - Log.DataInicio).TotalSeconds).ToString("HH:mm:ss");

            pnlOrientacaoCaminho.Invalidate();
            pnlOrientacaoDif.Invalidate();

            OperacaoModel.PopularTreeView(tvwFalhas, Log.ModulosSaude);
            tvwFalhas.ExpandAll();

            label117.Text = $"Impedimento: {Log.ErroOperacaoLiberada}";
            //label117.Text = $"Bat {Log.Bateria?.TensaoInstantanea} A, {Log.Bateria?.CorrenteInstantanea} A, {Log.Bateria?.PercentualBateria} %";
        }

        private void AtualizarInformacoesCameras()
        {
            picCameraCaminho.Image = CarregarImagemCamera(pathImagensCaminho, "_rgb");
            AtualizarInformacoesCameraCaminho();

            for (int i = 0; i < LogsOperacao[idxMomentoAtual].Atuador.QtdCamerasSolo; i++)
            {
                Bitmap bitmapSolo = CarregarImagemCamera(pathImagensSolo[i], "_rgb");
                if (chbDesenharErvas.Checked)
                {
                    var LogCamSolo = LogsOperacao[idxMomentoAtual].OperadorErvas;
                    if (LogCamSolo != null)
                    {
                        bitmapSolo = DesenharDeteccoesErvas(LogCamSolo.Analise, bitmapSolo);
                        picsCamSolo[i].Image = bitmapSolo;
                    }
                }
                else
                {
                    picsCamSolo[i].Image = bitmapSolo;
                }
                Bitmap bitmapSoloSeg = CarregarImagemCamera(pathImagensSolo[i], "_segmentacao");
                picsCamSoloSeg[i].Image = bitmapSoloSeg;
                Bitmap bitmapSoloOverlay = FuncoesGlobais.FazerOverlay(bitmapSolo, bitmapSoloSeg);
                picsCamSoloOverlay[i].Image = bitmapSoloOverlay;
            }


            graficoCameras.AtualizarDados(idxMomentoAtual);

            if (cmbCameras_Componente.SelectedIndex > -1)
            {
                var Valores = graficoCameras.Series.FirstOrDefault(x => x.Titulo == cmbCameras_Componente.Text).Valores.Take(idxMomentoAtual + 1).ToList();
                txtCameras_Atual.Text = Valores[idxMomentoAtual].ToString("0.00");
                txtCameras_Media.Text = Valores.Average().ToString("0.00");
                txtCameras_Mediana.Text = FuncoesMatematicas.CalcularMediana(Valores).ToString("0.00");
                txtCameras_Moda.Text = FuncoesMatematicas.CalcularModa(Valores).ToString("0.00");
                txtCameras_Minimo.Text = Valores.Min().ToString("0.00");
                txtCameras_Maximo.Text = Valores.Max().ToString("0.00");
            }
        }

        private void AtualizarInformacoesGPS()
        {
            var Log = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual).Gps;
            txtGPS_Altitude.Text = (Log?.Altitude ?? 0).ToString();
            txtGPS_Data.Text = (Log?.DataHora ?? MomentoAtual).ToString("dd/MM HH:mm:ss");
            txtGPS_Latitude.Text = (Log?.Latitude ?? 0).ToString();
            txtGPS_Longitude.Text = (Log?.Longitude ?? 0).ToString();
            txtGPS_Correcao.Text = ((Log?.Ntrip_ativado ?? false) ? "N " : "B ") + (Log?.IdadeCorrecao ?? -1) + ": " + (Log?.QualidadeFix ?? Enums.TiposCorrecaoGPS.SemCorrecao).ToString();
            txtGPS_Precisao.Text = (Log?.PrecisaoCm ?? 0).ToString("0.00") + " cm";
            txtGPS_Satelites.Text = (Log?.NumeroSatelites ?? 0).ToString();
            //txtGPS_DistanciaBase.Text = (Log?.Velocidade ?? 0).ToString("0.00") + " (" + ((Log?.Velocidade ?? 0) * GPSUtils.ConversaoNosKmh).ToString("0.00") + " km/h)";

            var LogLra = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual).DadosLoRa;

            txtGPS_DistanciaBase.Text = ((LogLra?.PosicaoBase?.Latitude != 0 && LogLra?.PosicaoBase?.Longitude != 0) ? GPSUtils.DistanciaEntrePontos(LogLra?.PosicaoBase ?? new GPSModel(), Log ?? new GPSModel()) : 0).ToString("0.00") + " m";

            GPSService.EnviarCoordenadasParaMapa(Log?.Latitude ?? 0, Log?.Longitude ?? 0, Log?.AnguloCarroDefinido ?? 0, true, LogLra?.EnderecoCarro ?? 0x00);
            GPSService.EnviarCoordenadasParaMapa(LogLra?.PosicaoBase?.Latitude ?? 0, LogLra?.PosicaoBase?.Longitude ?? 0, LogLra?.PosicaoBase?.AnguloCarroDefinido ?? 0, false, LogLra?.EnderecoBase ?? 0x01);

            lblGPS.ForeColor = !Log.Inicializado ? Color.Red : Color.Black;

            pnlOrientacaoGPS.Invalidate();

            var _trajaetoria = LogsOperacao.Select(x => new PontoTrajetoriaModel(Enums.TipoPontoRua.Indefinido)
            {
                Posicao = x.Gps
            })
            .ToList();


            var LogOpe = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual);
            var LogSnr = LogOpe.OperadorVisual;
            var LogsGPS = LogsOperacao.Select(x => x.Gps).ToList();

            MapaDinamico.AtualizarDados(
                //(LogSnr?.Iniciado ?? false) && LogSnr.Resumo.DirecaoDesvio != Enums.Direcao.Frente ? LogSnr.Resumo.ObstaculoCritico : null,
                null, 
                (float)LogOpe.Trajetoria.AnguloCaminho,
                (float)LogOpe.Gps.AnguloCarroDefinido,
                Log,
                _trajaetoria,
                Variaveis.OperacaoEmAndamento.Trajetoria?._TrajetoriaFixa,
                new List<GPSModel>(LogsGPS.Take(LogsGPS.IndexOf(Log) + 1)),
                Variaveis.OperacaoEmAndamento.Mapa.TrajetoriaMapa,
                LogOpe.Controle.SimulacaoMPC
            );
        }

        private void AtualizarInformacoesDirecional()
        {
            AtualizarInformacoesMotorDirecional("DF");
            AtualizarInformacoesMotorDirecional("DT");
            AtualizarInformacoesMotorDirecional("EF");
            AtualizarInformacoesMotorDirecional("ET");

            pnlOrientacaoDirecional.Invalidate();
        }

        private void AtualizarInformacoesMotorDirecional(string ID)
        {
            //var Log = LogsDirecional.Where(x => x.Mod_ID == ID).FirstOrDefault(x => x.Momento == MomentoAtual);
            var Log = LogsDirecional.Where(x => x.Mod_ID == ID).FirstOrDefault();
            var LogSen = LogsSensoriamento.FirstOrDefault(x => x.Momento == MomentoAtual);

            double Angulo = Log?.AnguloLeitura ?? 0;
            double Multiplicador = -1;
            Image img = Resources.roda_superior;
            if (ID.StartsWith("E"))
            {
                img = FuncoesGlobais.EspelharImagemHorizontalmente(img);
                //Multiplicador = -1;
            }
            if (ID == "EF" || ID == "DT")
            {
                Multiplicador = 1;
            }
            //Multiplicador = (Log?.Sentido_SP ?? Enums.Sentido.Parado) == Enums.Sentido.Antihorario ? -1 : 1;

            PictureBox pic = FuncoesGlobais.FindControlRecursive<PictureBox>(tabDirecional, "picDIR_" + ID);
            pic.Image = FuncoesGlobais.RotacionarImagem(img, Angulo * Multiplicador);

            Label lbl = FuncoesGlobais.FindControlRecursive<Label>(tabDirecional, "lblDIR_" + ID);
            lbl.ForeColor = Log.Iniciado ? Color.Green : Color.Red;

            TextBox txtAnguloSP = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_AnguloSP_" + ID);
            txtAnguloSP.Text = (Log?.Angulo_SP ?? 0).ToString();
            TextBox txtAngulo = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Angulo_" + ID);
            txtAngulo.Text = (Log?.AnguloLeitura ?? 0).ToString();
            TextBox txtSentidoSP = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_SentidoSP_" + ID);
            txtSentidoSP.Text = (Log?.Sentido_SP ?? Enums.Sentido.Parado).ToString();
            TextBox txtSentido = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Sentido_" + ID);
            txtSentido.Text = (Log?.Sentido ?? Enums.Sentido.Parado).ToString();
            TextBox txtVelocidade = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Velocidade_" + ID);
            txtVelocidade.Text = (Log?.Velocidade ?? 0).ToString();
            TextBox txtFolga = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Folga_" + ID);
            txtFolga.Text = (Log?.FolgaMecanica ?? 0).ToString();
            TextBox txtControlar = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Controlar_" + ID);
            txtControlar.Text = (Log?.Controlar ?? false) ? "Sim" : "Não";
            TextBox txtStatus = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Status_" + ID);
            txtStatus.Text = (Log?.SentidoReal ?? Enums.Sentido.Parado).ToString();
        }

        private void AtualizarInformacoesMovimentacao()
        {
            var Logs = LogsMovimentacao.Where(x => x.Momento == MomentoAtual).ToList();

            graficoMovGeral.AtualizarDados(idxMomentoAtual);
            graficoMovTemperatura.AtualizarDados(idxMomentoAtual);
            graficoMovAlimentacao.AtualizarDados(idxMomentoAtual);

            AtulizarDadosMotorMovimentacao("DF");
            AtulizarDadosMotorMovimentacao("DT");
            AtulizarDadosMotorMovimentacao("EF");
            AtulizarDadosMotorMovimentacao("ET");
        }

        private void AtulizarDadosMotorMovimentacao(string ID)
        {
            var Log = LogsMovimentacao.FirstOrDefault(x => x.Momento == MomentoAtual && x.Modulo_ID == ID);
            var Log_Sen = LogsSensoriamento.FirstOrDefault(x => x.Momento == MomentoAtual);
            double agET = Log_Sen.Servos?.FirstOrDefault(x => x.ID.Contains("ET"))?.ValoresLeituras?.FirstOrDefault(x => x.funcao == FuncoesPinout.ServoAnguloLeitura)?.atual?.valor ?? 0;
            double agDT = Log_Sen.Servos?.FirstOrDefault(x => x.ID.Contains("DT"))?.ValoresLeituras?.FirstOrDefault(x => x.funcao == FuncoesPinout.ServoAnguloLeitura)?.atual?.valor ?? 0;
            double agEF = Log_Sen.Servos?.FirstOrDefault(x => x.ID.Contains("EF"))?.ValoresLeituras?.FirstOrDefault(x => x.funcao == FuncoesPinout.ServoAnguloLeitura)?.atual?.valor ?? 0;
            double agDF = Log_Sen.Servos?.FirstOrDefault(x => x.ID.Contains("DF"))?.ValoresLeituras?.FirstOrDefault(x => x.funcao == FuncoesPinout.ServoAnguloLeitura)?.atual?.valor ?? 0;
            bool freio =
                (ID.Contains("ET") && agET > 0 && (agET < 180)) ||
                (ID.Contains("DT") && agDT > 0 && (agDT < 180)) ||
                (ID.Contains("EF") && agEF > 0 && (agEF < 180)) ||
                (ID.Contains("DF") && agDF > 0 && (agDF < 180));

            GroupBox gpbRpm = FuncoesGlobais.FindControlRecursive<GroupBox>(tabMovGreal, "gpbMOV_Geral_" + ID);
            gpbRpm.ForeColor = !Log.Inicializado ? Color.Red : Color.Black;
            CheckBox chbAlm = FuncoesGlobais.FindControlRecursive<CheckBox>(gpbRpm, "chbMOV_Alm_" + ID);
            chbAlm.Checked = Log.CodAlarme > 0;
            chbAlm.Text = $"Alarme ({Log.CodAlarme})";
            CheckBox chbEn = FuncoesGlobais.FindControlRecursive<CheckBox>(gpbRpm, "chbMOV_En_" + ID);
            chbEn.Checked = Log.Ativado;
            CheckBox chbBrk = FuncoesGlobais.FindControlRecursive<CheckBox>(gpbRpm, "chbMOV_Brk_" + ID);
            chbBrk.Checked = Log.EmFreio;
            TextBox txtSentidoSP = FuncoesGlobais.FindControlRecursive<TextBox>(gpbRpm, "txtMOV_SentidoSP_" + ID);
            txtSentidoSP.Text = freio ? Enums.Direcao.EmFreio.ToString() : Log.Sentido_SP.ToString();
            TextBox txtSentido = FuncoesGlobais.FindControlRecursive<TextBox>(gpbRpm, "txtMOV_Sentido_" + ID);
            txtSentido.Text = Log.EmFreio ? Enums.Direcao.EmFreio.ToString() : Log.Sentido.ToString();

            if (cmbMOV_Temperatura_Componente.SelectedIndex > -1)
            {
                var Valores = graficoMovTemperatura.Series.FirstOrDefault(x => x.Titulo == (ID + " " + cmbMOV_Temperatura_Componente.Text.Split(' ')[1])).Valores.Take(idxMomentoAtual + 1).ToList();

                GroupBox gpbTmp = FuncoesGlobais.FindControlRecursive<GroupBox>(tabMovTemperatura, "gpbMOV_Temperatura_" + ID);
                TextBox txtTmpAtual = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTmp, "txtMOV_TemperaturaAt_" + ID);
                txtTmpAtual.Text = Valores[idxMomentoAtual].ToString("0.00");
                TextBox txtTmpMinima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTmp, "txtMOV_TemperaturaMn_" + ID);
                txtTmpMinima.Text = Valores.Min().ToString("0.00");
                TextBox txtTmpMaxima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTmp, "txtMOV_TemperaturaMx_" + ID);
                txtTmpMaxima.Text = Valores.Max().ToString("0.00");

                int dado = (cmbMOV_Temperatura_Componente.SelectedIndex) / 4;

                double RetornaDadoTemperatura(MovSensoriamentoLogModel x) => dado == 0 ? x?.Temperatura ?? 0 : x?.TemperaturaDriver ?? 0;

                double valMin = 0;

                txtMOV_Temperatura_Media.Text = LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoTemperatura(x) > valMin && (chbMOV_Temperatura_Media.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Average(x => RetornaDadoTemperatura(x)).ToString("0.00");
                txtMOV_Temperatura_Mediana.Text = FuncoesMatematicas.CalcularMediana(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoTemperatura(x) > valMin && (chbMOV_Temperatura_Moda.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoTemperatura(x)).ToList()).ToString("0.00");
                txtMOV_Temperatura_Moda.Text = FuncoesMatematicas.CalcularModa(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoTemperatura(x) > valMin && (chbMOV_Temperatura_Mediana.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoTemperatura(x)).ToList()).ToString("0.00");
            }

            if (cmbMOV_AlImentacao_Componente.SelectedIndex > -1)
            {
                var Valores = graficoMovAlimentacao.Series.FirstOrDefault(x => x.Titulo == (cmbMOV_AlImentacao_Componente.Text.Split(' ')[0] + " " + ID)).Valores.Take(idxMomentoAtual + 1).ToList();

                GroupBox gpbTns = FuncoesGlobais.FindControlRecursive<GroupBox>(tabMovAlimentacao, "gpbMOV_Alimentacao_" + ID);
                TextBox txtTnsAtual = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTns, "txtMOV_AlimentacaoAt_" + ID);
                txtTnsAtual.Text = Valores[idxMomentoAtual].ToString("0.00");
                TextBox txtTnsMinima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTns, "txtMOV_AlimentacaoMn_" + ID);
                txtTnsMinima.Text = Valores.Min().ToString("0.00");
                TextBox txtTnsMaxima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTns, "txtMOV_AlimentacaoMx_" + ID);
                txtTnsMaxima.Text = Valores.Max().ToString("0.00");

                int dado = (cmbMOV_AlImentacao_Componente.SelectedIndex) / 4;

                double RetornaDadoAlimentacao(MovSensoriamentoLogModel x) => dado == 0 ? x?.Tensao ?? 0 : dado == 1 ? x?.Corrente_Motor ?? 0 : dado == 2 ? x?.Corrente_Barramento ?? 0 : dado == 3 ? x?.Potencia ?? 0 : x?.CicloTrabalho ?? 0;

                double valMin = 0;

                txtMOV_Alimentacao_Media.Text = LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoAlimentacao(x) > valMin && (chbMOV_Alimentacao_Media.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Average(x => RetornaDadoAlimentacao(x)).ToString("0.00");
                txtMOV_Alimentacao_Mediana.Text = FuncoesMatematicas.CalcularMediana(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoAlimentacao(x) > valMin && (chbMOV_Alimentacao_Moda.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoAlimentacao(x)).ToList()).ToString("0.00");
                txtMOV_Alimentacao_Moda.Text = FuncoesMatematicas.CalcularModa(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoAlimentacao(x) > valMin && (chbMOV_Alimentacao_Mediana.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoAlimentacao(x)).ToList()).ToString("0.00");
            }
        }

        private void AtualizarInformacoesAtuador()
        {
            graficoAtu?.AtualizarDados(idxMomentoAtual);
            graficoErvas?.AtualizarDados(idxMomentoAtual);

            pnlAtuadores.Invalidate();

            var Log = LogsAtuador.FirstOrDefault(x => x.Momento == MomentoAtual);
            if (Log == null)
            {
                return;
            }

            lblATU_QualidadeWifi.Text = $"Qualidade Wi-Fi: {Log.QualidadeWifi} dBm";
            lblATU_LatenciaLoop.Text = $"Latencia de Loop: {Log.LatenciaLoop} ms";
        }

        private void AtualizarInformacoesSensoriamento()
        {
            graficoSen.AtualizarDados(idxMomentoAtual);

            if (cmbSen_Componente.SelectedIndex > -1)
            {
                var Valores = graficoSen.Series.FirstOrDefault(x => x.Titulo == cmbSen_Componente.Text).Valores.Take(idxMomentoAtual + 1).ToList();
                txtSen_Atual.Text = Valores[idxMomentoAtual].ToString("0.00");
                txtSen_Media.Text = Valores.Average().ToString("0.00");
                txtSen_Mediana.Text = FuncoesMatematicas.CalcularMediana(Valores).ToString("0.00");
                txtSen_Moda.Text = FuncoesMatematicas.CalcularModa(Valores).ToString("0.00");
                txtSen_Minimo.Text = Valores.Min().ToString("0.00");
                txtSen_Maximo.Text = Valores.Max().ToString("0.00");
            }

            var LogImu = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual).IMU;
            if (LogImu != null)
            {
                lblMagnetometro.ForeColor = !LogImu.Iniciado ? Color.Red : Color.Black;
                pnlOrientacaoMagnetometro.Invalidate();
                pnlInclinacao.Invalidate();
                visualizador3D.AtualizarAngulos(LogImu.InclinacaoFrontal, LogImu.InclinacaoLateral, -LogsOperacao[idxMomentoAtual].Gps.OrientacaoReal);
                //txtTemperatura.Text = LogImu.Temperatura.ToString("0.00");
                //txtAltitude.Text = LogImu.Altitude.ToString("0.00");
                //txtPressao.Text = LogImu.Pressao + " Pa (" + (LogImu.Pressao / 101300.0).ToString("0.00") + " atm)";
            }

            var LogSen = LogsSensoriamento.FirstOrDefault(x => x.Momento == MomentoAtual);
            pnlManual.BackColor = LogSen.Sinaleiros?.FirstOrDefault(x => x.ID.Contains("MN"))?.ValoresLeituras?.FirstOrDefault(x => x.funcao == FuncoesPinout.StatusLedLeitura)?.atual?.valor == (int)Enums.StatusLED.Aceso ? Color.Yellow : Color.Gold;
            pnlAutomatico.BackColor = LogSen.Sinaleiros?.FirstOrDefault(x => x.ID.Contains("AT"))?.ValoresLeituras?.FirstOrDefault(x => x.funcao == FuncoesPinout.StatusLedLeitura)?.atual?.valor == (int)Enums.StatusLED.Aceso ? Color.Yellow : Color.Gold;
            pnlOperacao.BackColor = LogSen.Sinaleiros?.FirstOrDefault(x => x.ID.Contains("OP"))?.ValoresLeituras?.FirstOrDefault(x => x.funcao == FuncoesPinout.StatusLedLeitura)?.atual?.valor == (int)Enums.StatusLED.Aceso ? Color.Green : Color.DarkGreen;
            lblSEN_QualidadeWifi.Text = $"Qualidade Wi-Fi: {LogSen.QualidadeWifi} dBm";
            lblSEN_LatenciaLoop.Text = $"Latencia de Loop: {LogSen.LatenciaLoop} ms";

            /*var LogA05 = LogsA05.FirstOrDefault(x => x.Momento == MomentoAtual);

            foreach (var pnl in pnlUltrassom.Controls.OfType<Panel>().OrderBy(x => x.Name))
            {
                int id = int.Parse(pnl.Name.Replace("pnlP_", ""));
                var _Sensor = LogA05.Configuracao.Sensores.FirstOrDefault(x => (int)x.Posicao == id);

                pnl.Visible = _Sensor != null;
                pnl.BackColor = LogA05.Conectado && _Sensor != null && _Sensor.SensorAtuado ? Color.Red : Color.Gray;
                
                pnl.Tag = _Sensor != null ? $"{_Sensor.ID:00};{_Sensor.LeituraCm:F2}" : null;  // Armazena o ID e a Leitura no Tag do Panel

                pnl.Paint += (s, _e) =>
                {
                    // Pega o ID e a leitura armazenados no Tag, se houver
                    string tag = pnl.Tag?.ToString();
                    if (!string.IsNullOrEmpty(tag))
                    {
                        var parts = tag.Split(';');
                        string sensorID = parts[0];
                        string leitura = parts.Length > 1 ? parts[1] : "";

                        Font font = new Font("Arial", 9, FontStyle.Bold);
                        // Calcula a posição para o ID do sensor (primeira linha)
                        SizeF idSize = _e.Graphics.MeasureString(sensorID, font);
                        float idX = (pnl.Width - idSize.Width) / 2;
                        float idY = (pnl.Height - idSize.Height) / 8; // Ajuste para centralizar no terço superior
                        _e.Graphics.DrawString(sensorID, font, Brushes.White, idX, idY);

                        // Calcula a posição para o valor de leitura (segunda linha)
                        Font fontLeitura = new Font("Arial", 7, FontStyle.Regular);
                        SizeF leituraSize = _e.Graphics.MeasureString(leitura, fontLeitura);
                        float leituraX = (pnl.Width - leituraSize.Width) / 2;
                        float leituraY = idY + idSize.Height + 1; // Posiciona logo abaixo do ID
                        _e.Graphics.DrawString(leitura, fontLeitura, Brushes.White, leituraX, leituraY);
                    }
                };

                pnl.Invalidate();  // Redesenha o Panel para aplicar as mudanças
            }*/

        }

        private void AtualizarInformacoesSonar()
        {
            var Log = LogsOperacao[idxMomentoAtual].OperadorVisual.Analises;
            txtSonarDistanciaObstaculo.Text = (Log.matriz_confianca?.block?.d_obs_true_min_m ?? 0).ToString("0.00");
            txtSonarDistanciaParada.Text = (Log.matriz_confianca?.block?.decision?.dist_necessaria ?? 0).ToString("0.00");
            txtSonarDecisao.Text = (Log.matriz_confianca?.block?.reason_detail ?? "");

            // OAK-D Lite
            /*if (gridObstaculos.Columns.Count == 0)
            {
                gridObstaculos.Columns.Clear();

                gridObstaculos.Columns.Add("clDeteccao", "Detecção");
                gridObstaculos.Columns.Add("clConfianca", "Confiança");
            }
            gridObstaculos.Rows.Clear();
            if (Log?.deteccao != null)
            {
                foreach (var obstaculo in Log.deteccao)
                {
                    gridObstaculos.Rows.Add
                    (
                        obstaculo.label,
                        obstaculo.conf
                    );
                }
            }*/

            

            picMapaCalor.Image = CarregarImagemCamera(pathImagensCaminho, "_heatmap");

            picSonarRadar.Image = CarregarImagemCamera(pathImagensCaminho, "_radar");

            Bitmap rgb = CarregarImagemCamera(pathImagensCaminho, "_rgb");
            Bitmap seg = CarregarImagemCamera(pathImagensCaminho, "_segmentacao");
            pnlSonarDeteccoes.BackgroundImage = FuncoesGlobais.FazerOverlay(rgb, seg);
            pnlSonarDeteccoes.Invalidate();

            //if (chbSonarDeteccoes.Checked)
            //{
            //    picSonarRadar.Image?.Dispose();
            //    //picSonarRadar.Image = Log.Leitura.obj.radar_2d.PlotarAnalsie((Bitmap)picSonarRadar.Image.Clone());
            //}

            var LogLvx = LogsOperacao[idxMomentoAtual].LivoxLidar;
            // MID-360
            var g = gridObstaculos;
            if (g.Columns.Count == 0)
            {
                g.Columns.Clear();
                g.Columns.Add("clDist", "Dist (m)");
                g.Columns.Add("clFrente", "Frente (m)");
                g.Columns.Add("clLateral", "Lat (m)");
                g.Columns.Add("clW", "W (m)");
                g.Columns.Add("clD", "D (m)");
                g.Columns.Add("clH", "H (m)");
                g.Columns.Add("clVoxels", "Voxels");
                g.Columns.Add("clTempo", "t (ms)");
            }
            g.Rows.Clear();
            if (LogLvx != null)
            {
                foreach (var b in LogLvx.bboxes.OrderBy(x => x.dist_xy_m))
                {
                    g.Rows.Add(
                        b.dist_xy_m.ToString("0.00"),
                        b.frente_m.ToString("0.00"),
                        b.cy.ToString("0.00"),
                        b.w.ToString("0.00"),
                        b.d.ToString("0.00"),
                        b.h.ToString("0.00"),
                        b.voxels,
                        b.t_ms
                    );
                }

                view_top_down.SetBboxes(LogLvx.bboxes);
                view_frontal.SetBboxes(LogLvx.bboxes);
                pnlTridimensional.Invalidate();
                view_3d.SetBboxes(LogLvx.bboxes);
            }
            
        }

        private void AtualizarInformacoesCameraCaminho()
        {
            var Log = LogsOperacao[idxMomentoAtual];
            txtCamCaminhoErroAngular.Text = (Log.OperadorVisual?.Analises?.segmentacao?.erro_angular ?? 0).ToString("0.00");
            txtCamCaminhoErroLateral.Text = (Log.OperadorVisual?.Analises?.segmentacao?.erro_lateral_pct ?? 0).ToString("0.00");
            txtCamCaminhoStatusCarro.Text = (Log.OperadorVisual?.Analises?.segmentacao?.status_corredor ?? Enums.StatusCarroMapa.Parado).ToString();

            //txtTempoEntrandoRua.Text = Log.Trajetoria.CorredorAtual.TempoPorStatus.FirstOrDefault(x => x.Key == Enums.StatusCarroMapa.EntrandoRua).Value.ToString("0.00") + " s";
            //txtTempoCaminhandoRua.Text = Log.Trajetoria.CorredorAtual.TempoPorStatus.FirstOrDefault(x => x.Key == Enums.StatusCarroMapa.CaminhandoRua).Value.ToString("0.00") + " s";
            //txtTempoSaindoRua.Text = Log.Trajetoria.CorredorAtual.TempoPorStatus.FirstOrDefault(x => x.Key == Enums.StatusCarroMapa.SaindoRua).Value.ToString("0.00") + " s";
            //txtTempoParado.Text = Log.Trajetoria.CorredorAtual.TempoPorStatus.FirstOrDefault(x => x.Key == Enums.StatusCarroMapa.Parado).Value.ToString("0.00") + " s";
            //txtTempoDirecionando.Text = Log.Trajetoria.CorredorAtual.TempoPorStatus.FirstOrDefault(x => x.Key == Enums.StatusCarroMapa.Direcionando).Value.ToString("0.00") + " s";
            //txtTempoManobrando.Text = Log.Trajetoria.CorredorAtual.TempoPorStatus.FirstOrDefault(x => x.Key == Enums.StatusCarroMapa.Manobrando).Value.ToString("0.00") + " s";

            pnlCaminho.BackgroundImage = CarregarImagemCamera(pathImagensCaminho, "_segmentacao");
            pnlCaminho.BackgroundImageLayout = ImageLayout.Zoom;
            pnlCaminho.Invalidate();
        }

        private void AtualizarInformacoesCPU()
        {
            graficoCpu.AtualizarDados(idxMomentoAtual);

            if (cmbCpu_Componente.SelectedIndex > -1)
            {
                var Valores = graficoCpu.Series.FirstOrDefault(x => x.Titulo == cmbCpu_Componente.Text).Valores.Take(idxMomentoAtual + 1).ToList();
                txtCpu_Atual.Text = Valores[idxMomentoAtual].ToString("0.00");
                txtCpu_Media.Text = Valores.Average().ToString("0.00");
                txtCpu_Mediana.Text = FuncoesMatematicas.CalcularMediana(Valores).ToString("0.00");
                txtCpu_Moda.Text = FuncoesMatematicas.CalcularModa(Valores).ToString("0.00");
                txtCpu_Minimo.Text = Valores.Min().ToString("0.00");
                txtCpu_Maximo.Text = Valores.Max().ToString("0.00");
            }
        }

        private void AtualizarInformacoesComandos()
        {
            var Log = LogsOperacao[idxMomentoAtual].Controle;

            foreach (var controle in Log.TiposControle)
            {
                DataGridView dt = FuncoesGlobais.FindControlRecursive<DataGridView>(tabComandos, "dtComandos" + controle.Tipo.ToString());
                dt.Rows.Clear();
                foreach (var comando in controle.Comandos)
                {
                    dt.Rows.Add(comando.Split(';'));
                }
            }
        }

        private void AtualizarInformacoesMPC()
        {
            bool ordenarPorCustoTotal = true;
            Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel> dict = LogsOperacao[idxMomentoAtual].Controle.DebugCustoMpc;
            TreeView tv = tvwMPC;

            tv.BeginUpdate();
            tv.Nodes.Clear();

            // rank global e margem (diferença p/ o próximo)
            var ordered = dict
                .Select(kv => new {
                    kv.Key,
                    Cost = ordenarPorCustoTotal ? kv.Value.custo_total : kv.Value.custo_map
                })
                .OrderBy(x => x.Cost)
                .ToList();

            var rank = new Dictionary<string, (int rank, double cost, double margin)>();
            for (int i = 0; i < ordered.Count; i++)
            {
                double margin = (i < ordered.Count - 1) ? (ordered[i + 1].Cost - ordered[i].Cost) : 0.0;
                rank[ordered[i].Key] = (i + 1, ordered[i].Cost, margin);
            }

            // agrupar por tipo
            var porTipo = dict.GroupBy(kv => CandMpcKey.ParseKey(kv.Key).Tipo);
            foreach (var g in porTipo.OrderBy(gr => gr.Key.ToString()))
            {
                var tipoNode = tv.Nodes.Add(g.Key.ToString());

                // ordenar ângulos
                foreach (var kv in g.OrderBy(kv => CandMpcKey.ParseKey(kv.Key).AngDeg))
                {
                    var k = CandMpcKey.ParseKey(kv.Key);
                    var m = kv.Value;
                    var r = rank[kv.Key];

                    string angleTxt = k.AngDeg.ToString("+0.00;-0.00;0.00", CultureInfo.InvariantCulture);
                    string yLabel = ordenarPorCustoTotal ? "ctot" : "cmap";
                    double yVal = ordenarPorCustoTotal ? m.custo_total : m.custo_map;

                    // nó do ângulo (resumo compacto)
                    var angNode = tipoNode.Nodes.Add($"ang {angleTxt}°  #{r.rank}  Δ={r.margin:0.000}  {yLabel}={yVal:0.0000}");

                    angNode.Tag = kv.Key;

                    // destaque visual
                    if (r.rank == 1)
                    {
                        angNode.NodeFont = new Font(tv.Font, FontStyle.Bold);
                        angNode.ForeColor = Color.ForestGreen;
                    }
                    else if (r.rank == 2)
                    {
                        angNode.ForeColor = Color.DarkOrange;
                    }
                    if (m.melhor)
                    {
                        angNode.NodeFont = new Font(tv.Font, FontStyle.Bold);
                        angNode.ForeColor = Color.DarkBlue;
                    }

                    // ---- Subgrupos
                    var pose = angNode.Nodes.Add("Pose/Alvo");
                    pose.Nodes.Add($"Rover: X={m.x_sim:0.00000}  Y={m.y_sim:0.00000}  θ={m.theta_sim:0.00}");
                    pose.Nodes.Add($"Alvo: X={m.x_alvo:0.00000}  Y={m.y_alvo:0.00000}");

                    var errs = angNode.Nodes.Add("Erros");
                    errs.Nodes.Add($"Posição={m.erro_posicao:0.00000}  Normalizado={m.erro_posicao_n:0.00000}");
                    errs.Nodes.Add($"Orientação={m.erro_orientacao:0.00000}  Normalizado={m.erro_orientacao_n:0.00000}");
                    errs.Nodes.Add($"Suavização={m.erro_suavizacao:0.00000}");
                    errs.Nodes.Add($"Ré={m.erro_re:0.00000}");
                    errs.Nodes.Add($"Lateral={m.erro_lateral:0.00000}  Normalizado={m.erro_lateral_n:0.00000}");
                    

                    var costs = angNode.Nodes.Add("Custos");
                    costs.Nodes.Add($"Posição={m.custo_posicao:0.00000}");
                    costs.Nodes.Add($"Orientação={m.custo_orientacao:0.00000}");
                    costs.Nodes.Add($"Suavização={m.custo_suavizacao:0.00000}");
                    costs.Nodes.Add($"Ré={m.custo_re:0.00000}");
                    costs.Nodes.Add($"Ideal={m.custo_visual_worker:0.00000}");
                    costs.Nodes.Add($"Lateral={m.custo_lateral:0.00000}");
                    costs.Nodes.Add($"Lateral Derivado={m.custo_lateral_d:0.00000}");
                    costs.Nodes.Add($"Lateral Flip={m.custo_flip:0.00000}");
                    costs.Nodes.Add($"Somatória={m.custo_map:0.00000}");
                    costs.Nodes.Add($"Total={m.custo_total:0.00000}");

                    var pesos = angNode.Nodes.Add("Pesos");
                    pesos.Nodes.Add($"Posição={m.peso_posicao:0.00}");
                    pesos.Nodes.Add($"Orientação={m.peso_orientacao:0.00}");
                    pesos.Nodes.Add($"Suavização={m.peso_suavizacao:0.00}");
                    pesos.Nodes.Add($"Ré={m.peso_re:0.00}");
                    pesos.Nodes.Add($"Ideal={m.peso_ideal:0.00}");
                    pesos.Nodes.Add($"Lateral={m.peso_lateral:0.00}");
                    if (m.peso_tipo_movimento != null)
                    {
                        var ptip = pesos.Nodes.Add("Tipo de Movimento");
                        foreach (var kvp in m.peso_tipo_movimento)
                            ptip.Nodes.Add($"{kvp.Key}: {kvp.Value:0.00}");
                    }
                }
            }

            tv.ExpandAll(); // ou deixe colapsado se preferir
            tv.EndUpdate();
        }



        private void pnlOrientacaoDirecional_Paint(object sender, PaintEventArgs e)
        {
            var LogOp = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual);
            double Angulo = LogOp?.Controle?.Angulo ?? 0;
            Enums.Direcao direcaoControle = (LogOp?.Controle.TiposControle?.FirstOrDefault(x => x.Tipo == Enums.T_Code.Dir).UltimaDirecao ?? Enums.Direcao.Parado);
            //Angulo *=
            //    direcaoControle == Enums.Direcao.Esquerda ? -1 :
            //    direcaoControle == Enums.Direcao.Direita ? 1 :
            //    0;
            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)Angulo, 90);
        }

        private void pnlOrientacaoGPS_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual)?.Gps;

            double AnguloGps = Log?.OrientacaoReal ?? 0;
            double AnguloMovimento = Log?.OrientacaoMovimento ?? 0;
            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)AnguloGps, 90, (float)AnguloMovimento);
        }

        private void pnlOrientacaoMagnetometro_Paint(object sender, PaintEventArgs e)
        {
            /*var Log = LogsSensoriamento.FirstOrDefault(x => x.Momento == MomentoAtual)?.SensoresIMU?.FirstOrDefault();

            double Angulo = (Log?.Yaw ?? 0);
            double AnguloCorrigido = (Log?.YawFixed ?? 0);

            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)Angulo, 90.0f, (float)AnguloCorrigido);*/
        }

        private void pnlOrientacaoCaminho_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual);

            double Angulo = Log?.Trajetoria.ProximoPonto.Orientacao ?? 0;
            double AnguloMedio = Log?.Trajetoria.AnguloCaminho ?? 0;

            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)Angulo, 90, (float)AnguloMedio);
        }

        private void pnlOrientacaoDif_Paint(object sender, PaintEventArgs e)
        {
            var Logs = LogsOperacao.Where(x => x.Momento == MomentoAtual).ToList();
            double Angulo = Logs.Any() ? Logs.Average(x => x.Trajetoria.ErroOrientacaoAngularProximoPonto) : 0;
            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)Angulo, 90);
        }

        private void pnlAtuadores_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsAtuador.FirstOrDefault(x => x.Momento == MomentoAtual);
            if (Log == null)
            {
                return;
            }

            AtuadorFuncoesGerais.DesenharAtuadores(pnlAtuadores, e, Log.Bicos, Log.PotenciaBomba > 0, Log.PressaoLinha, Log.TempoPulverizadorAtuado);
        }

        private void pnlInclinacao_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = e.Graphics;
            int centerX = pnlInclinacao.Width / 2;
            int centerY = pnlInclinacao.Height / 2;
            int radius = 10;

            // Desenhar fundo com bordas arredondadas
            GraphicsPath path = new GraphicsPath();
            int cornerRadius = 20;
            path.AddArc(0, 0, cornerRadius, cornerRadius, 180, 90);
            path.AddArc(pnlInclinacao.Width - cornerRadius, 0, cornerRadius, cornerRadius, 270, 90);
            path.AddArc(pnlInclinacao.Width - cornerRadius, pnlInclinacao.Height - cornerRadius, cornerRadius, cornerRadius, 0, 90);
            path.AddArc(0, pnlInclinacao.Height - cornerRadius, cornerRadius, cornerRadius, 90, 90);
            path.CloseAllFigures();

            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.FillPath(new SolidBrush(Color.LightBlue), path);
            g.DrawPath(new Pen(Color.DarkBlue, 2), path);

            // Desenhar linhas de referência
            Pen pen = new Pen(Color.Gray, 1);
            g.DrawLine(pen, centerX, 0, centerX, pnlInclinacao.Height);
            g.DrawLine(pen, 0, centerY, pnlInclinacao.Width, centerY);

            // Desenhar linhas adicionais para ângulos
            for (int i = -90; i <= 90; i += 15)
            {
                int posX = centerX + (int)(i * (pnlInclinacao.Width / 2 - radius) / 90);
                int posY = centerY - (int)(i * (pnlInclinacao.Height / 2 - radius) / 90);
                g.DrawLine(pen, centerX, centerY, posX, centerY);
                g.DrawLine(pen, centerX, centerY, centerX, posY);
            }

            // Desenhar régua na linha central
            for (int i = -90; i <= 90; i += 15)
            {
                int posX = centerX + (int)(i * (pnlInclinacao.Width / 2 - radius) / 90);
                int posY = centerY - (int)(i * (pnlInclinacao.Height / 2 - radius) / 90);

                // Marcas horizontais
                g.DrawLine(pen, posX, centerY - 5, posX, centerY + 5);
                g.DrawString(i.ToString(), new Font("Arial", 8), Brushes.Black, posX - 10, centerY + 10);

                // Marcas verticais
                g.DrawLine(pen, centerX - 5, posY, centerX + 5, posY);
                g.DrawString(i.ToString(), new Font("Arial", 8), Brushes.Black, centerX + 10, posY - 5);
            }

            // Calcular a posição do círculo com base nos ângulos
            var Log = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual).IMU;
            int circlePosX = centerX + (int)((Log?.InclinacaoLateral ?? 0) * (pnlInclinacao.Width / 2 - radius) / 90);
            int circlePosY = centerY - (int)((Log?.InclinacaoFrontal ?? 0) * (pnlInclinacao.Height / 2 - radius) / 90);

            // Desenhar o círculo
            Brush brush = new SolidBrush(Color.Red);
            g.FillEllipse(brush, circlePosX - radius, circlePosY - radius, radius * 2, radius * 2);
        }

        private void pnlCaminho_Paint(object sender, PaintEventArgs e)
        {
            if (!chbDesenharCorredor.Checked) return;
            int _robotWidthPxOnImage = 100;

            var panel = (Panel)sender;
            var g = e.Graphics;
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            var _segDebug = LogsOperacao[idxMomentoAtual].OperadorVisual?.Analises?.segmentacao;

            // pré-checagens
            if (_segDebug == null) return;
            if (_segDebug.centros_corredor == null || _segDebug.centros_corredor.Count < 2) return;
            if (panel.BackgroundImage == null) return;

            // 1) Calcula onde a imagem é desenhada dentro do Panel (considera Layout=Zoom, Stretch, Center, etc.)
            Rectangle bounds = panel.ClientRectangle;
            Size imgSize = panel.BackgroundImage.Size;
            var layout = panel.BackgroundImageLayout;
            Rectangle destRect;

            switch (layout)
            {
                case ImageLayout.None:
                    destRect = new Rectangle(bounds.Location, imgSize);
                    break;
                case ImageLayout.Tile:
                    destRect = bounds; // pra overlay, tratamos como cobrindo tudo
                    break;
                case ImageLayout.Center:
                    destRect = new Rectangle(
                        bounds.X + (bounds.Width - imgSize.Width) / 2,
                        bounds.Y + (bounds.Height - imgSize.Height) / 2,
                        imgSize.Width, imgSize.Height);
                    break;
                case ImageLayout.Stretch:
                    destRect = bounds;
                    break;
                case ImageLayout.Zoom:
                default:
                    float rx = (float)bounds.Width / imgSize.Width;
                    float ry = (float)bounds.Height / imgSize.Height;
                    float r = Math.Min(rx, ry);
                    int w = (int)(imgSize.Width * r);
                    int h = (int)(imgSize.Height * r);
                    int x = bounds.X + (bounds.Width - w) / 2;
                    int y = bounds.Y + (bounds.Height - h) / 2;
                    destRect = new Rectangle(x, y, w, h);
                    break;
            }

            // 2) Mapeamento de coordenadas da SEGMENTAÇÃO (seg.width/seg.height) -> painel
            // (use o tamanho que gerou os 'centros_corredor')
            float sx = (float)destRect.Width / Math.Max(1, _segDebug.width);
            float sy = (float)destRect.Height / Math.Max(1, _segDebug.height);

            PointF Map(double xImg, double yImg)
                => new PointF(destRect.X + (float)(xImg * sx), destRect.Y + (float)(yImg * sy));

            // largura do robô nas coordenadas do painel
            float halfRobot = (float)(_robotWidthPxOnImage * sx * 0.5);

            // 3) Desenho: linha central, pontos e largura do robô em cada ponto
            var penCenter = new Pen(Color.FromArgb(255, 255, 0), 2f);     // amarelo
            var penRobot = new Pen(Color.FromArgb(255, 0, 255), 1.5f);   // magenta
            var brushPt = new SolidBrush(Color.FromArgb(255, 255, 0));
            float rPt = 3.5f;

            // mapeia os pontos
            var pts = _segDebug.centros_corredor
                .Where(p => p != null && p.Length >= 2)
                .Select(p => Map(p[0], p[1]))
                .ToArray();

            if (pts.Length < 2) return;

            // linha central do corredor
            g.DrawLines(penCenter, pts);

            // pontos e largura do robô por ponto
            foreach (var p in pts)
            {
                g.FillEllipse(brushPt, p.X - rPt, p.Y - rPt, 2 * rPt, 2 * rPt);
                g.DrawLine(penRobot, p.X - halfRobot, p.Y, p.X + halfRobot, p.Y);
            }
        }

        private void pnlSonarDeteccoes_Paint(object sender, PaintEventArgs e)
        {
            var panel = (Panel)sender;
            var g = e.Graphics;
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            var _snap = LogsOperacao[idxMomentoAtual].OperadorVisual.Analises.matriz_confianca;

            if (_snap == null || panel.BackgroundImage == null) return;

            int W = _snap.grid_w;
            int H = _snap.grid_h;
            if (W <= 0 || H <= 0) return;

            // -- destRect da imagem (respeita BackgroundImageLayout=Zoom)
            Rectangle bounds = panel.ClientRectangle;
            Size imgSize = panel.BackgroundImage.Size;
            Rectangle destRect;
            switch (panel.BackgroundImageLayout)
            {
                case ImageLayout.Stretch: destRect = bounds; break;
                case ImageLayout.Center:
                    destRect = new Rectangle(
                        bounds.X + (bounds.Width - imgSize.Width) / 2,
                        bounds.Y + (bounds.Height - imgSize.Height) / 2,
                        imgSize.Width, imgSize.Height);
                    break;
                case ImageLayout.None:
                    destRect = new Rectangle(bounds.Location, imgSize);
                    break;
                case ImageLayout.Zoom:
                default:
                    float rx = (float)bounds.Width / imgSize.Width;
                    float ry = (float)bounds.Height / imgSize.Height;
                    float r = Math.Min(rx, ry);
                    int w = (int)(imgSize.Width * r);
                    int h = (int)(imgSize.Height * r);
                    int x = bounds.X + (bounds.Width - w) / 2;
                    int y = bounds.Y + (bounds.Height - h) / 2;
                    destRect = new Rectangle(x, y, w, h);
                    break;
            }

            // helpers de mapeamento da GRID -> painel
            float cellW = (float)destRect.Width / W;
            float cellH = (float)destRect.Height / H;
            Func<int, int, PointF> CenterOfCell = (i, j) =>
                new PointF(destRect.X + (i + 0.5f) * cellW, destRect.Y + (j + 0.5f) * cellH);

            // --- central_cols (fallback: terço central)
            int c0 = W / 3;
            int c1 = 2 * W / 3;

            // --- linha que bloqueia (se houver)
            var blk = _snap.block;
            int? j_block = null;
            // reason_detail/blocked já estão em blk; j_block em si não veio no seu modelo.
            // Então projetamos a "linha foco" pela distância de bloqueio quando existir:
            // fallback simples: escolher a linha cujo row_dist_m é mais próxima de d_obs_true_min_m.
            if (blk != null && _snap.row_dist_m != null && _snap.row_dist_m.Count == H)
            {
                float? dRef = blk.d_block_line_m ?? (float?)blk.d_obs_true_min_m;
                if (dRef.HasValue && dRef.Value > 0)
                {
                    float bestAbs = float.MaxValue;
                    int bestJ = -1;
                    for (int j = 0; j < H; j++)
                    {
                        float drow = _snap.row_dist_m[j];
                        float diff = Math.Abs(drow - dRef.Value);
                        if (diff < bestAbs) { bestAbs = diff; bestJ = j; }
                    }
                    if (bestJ >= 0) j_block = bestJ;
                }
            }

            // desenha a região central (guias)
            var penCols = new Pen(Color.FromArgb(160, 255, 255, 255), 1f);
            float xC0 = destRect.X + c0 * cellW;
            float xC1 = destRect.X + c1 * cellW;
            g.DrawLine(penCols, xC0, destRect.Top, xC0, destRect.Bottom);
            g.DrawLine(penCols, xC1, destRect.Top, xC1, destRect.Bottom);

            // Desenha linha horizontal na j_block + janela do robô
            if (j_block.HasValue)
            {
                int jb = Math.Max(0, Math.Min(H - 1, j_block.Value));
                float y = destRect.Y + (jb + 0.5f) * cellH;

                var penLine = new Pen(blk.blocked ? Color.Red : Color.Yellow, 2f);
                g.DrawLine(penLine, destRect.Left, y, destRect.Right, y);

                // largura necessária em colunas nessa linha
                float widthNeedM = (float)(VariaveisEquipamento.LarguraEquipamentoMm / 1000.0);
                int ncols = c1 - c0;
                if (_snap.row_scale_x_m != null && _snap.row_scale_x_m.Count == H)
                {
                    float sx_m_per_col = _snap.row_scale_x_m[jb];
                    if (sx_m_per_col > 1e-6f)
                        ncols = Math.Max(1, Math.Min(W, (int)Math.Ceiling(widthNeedM / sx_m_per_col)));
                }
                int mid = (c0 + c1) / 2;
                int a = Math.Max(0, mid - ncols / 2);
                int b = Math.Min(W, a + ncols);
                a = Math.Max(0, b - ncols);

                // retângulo central na linha de bloqueio
                float x1 = destRect.X + a * cellW;
                float x2 = destRect.X + b * cellW;
                var rect = Rectangle.FromLTRB((int)x1, (int)(y - 10), (int)x2, (int)(y + 10));
                var penWin = new Pen(Color.Lime, 2f);
                g.DrawRectangle(penWin, rect);
            }

            // Status no canto
            string status = $"BLOCKED: {blk?.blocked ?? false} ({blk?.reason ?? "none"})";
            var font = new Font("Consolas", 10f, FontStyle.Bold);
            var col = (blk?.blocked ?? false) ? Color.Red : Color.LimeGreen;
            var br = new SolidBrush(col);
            var brBg = new SolidBrush(Color.FromArgb(120, 0, 0, 0));
            var sz = g.MeasureString(status, font);
            var box = new RectangleF(panel.ClientSize.Width - sz.Width - 12, 8, sz.Width + 8, sz.Height + 6);
            g.FillRectangle(brBg, box);
            g.DrawString(status, font, br, box.X + 4, box.Y + 3);

            if (chbSonarDeteccoes.Checked)
            {
                var _deteccoes = LogsOperacao[idxMomentoAtual].OperadorVisual.Analises.deteccao;
                // === DESENHAR DETECÇÕES (bboxes + label/conf) ===
                if (_deteccoes != null && _deteccoes.Count > 0)
                {
                    // tamanho da imagem original (a mesma do BackgroundImage)
                    int imgW = panel.BackgroundImage.Width;
                    int imgH = panel.BackgroundImage.Height;

                    // mapeia coordenadas da IMAGEM -> painel (considerando destRect)
                    float sxImg = (float)destRect.Width / Math.Max(1, imgW);
                    float syImg = (float)destRect.Height / Math.Max(1, imgH);

                    RectangleF MapImgRect(double x0, double y0, double x1, double y1)
                    {
                        // coords em px da imagem -> px do painel
                        float X0 = destRect.X + (float)(x0 * sxImg);
                        float Y0 = destRect.Y + (float)(y0 * syImg);
                        float X1 = destRect.X + (float)(x1 * sxImg);
                        float Y1 = destRect.Y + (float)(y1 * syImg);
                        // normaliza caso entre invertido
                        float left = Math.Min(X0, X1), top = Math.Min(Y0, Y1);
                        float right = Math.Max(X0, X1), bottom = Math.Max(Y0, Y1);
                        return new RectangleF(left, top, right - left, bottom - top);
                    }

                    var penBox = new Pen(Color.Lime, 2f); // cor da bbox
                    var brBg2 = new SolidBrush(Color.FromArgb(180, 0, 0, 0)); // fundo do rótulo
                    var brText = new SolidBrush(Color.White);
                    var fontLbl = new Font("Consolas", 9f, FontStyle.Bold);

                    foreach (var d in _deteccoes)
                    {
                        // escolhe fonte das coordenadas: bbox_px (preferível) ou bbox_norm
                        double x0, y0, x1, y1;
                        if (d.bbox_norm != null && d.bbox_norm.Count >= 4)
                        {
                            x0 = d.bbox_norm[0] * imgW; y0 = d.bbox_norm[1] * imgH;
                            x1 = d.bbox_norm[2] * imgW; y1 = d.bbox_norm[3] * imgH;
                        }
                        else
                        {
                            continue; // sem bbox válida
                        }

                        // ignora caixas muito pequenas
                        if (Math.Abs(x1 - x0) < 2 || Math.Abs(y1 - y0) < 2) continue;

                        // rect no painel
                        var rect = MapImgRect(x0, y0, x1, y1);

                        // clipe simples ao destRect (pra não “vazar” fora da imagem)
                        var inter = RectangleF.Intersect(rect, destRect);
                        if (inter.Width < 2 || inter.Height < 2) continue;

                        // desenha bbox
                        g.DrawRectangle(penBox, inter.X, inter.Y, inter.Width, inter.Height);

                        // rótulo + confiança
                        string labelTxt = string.IsNullOrEmpty(d.label) ? $"id:{d.label_id}" : d.label;
                        string txt = $"{labelTxt} {d.conf:0.00}";
                        var sz2 = g.MeasureString(txt, fontLbl);

                        // fundo do rótulo (acima da bbox, se couber; senão, dentro)
                        float pad = 3f;
                        float bx = inter.X;
                        float by = inter.Y - sz2.Height - 2; // acima
                        if (by < destRect.Top) by = inter.Y + 2; // fallback: dentro da caixa

                        var box2 = new RectangleF(bx, by, sz2.Width + 2 * pad, sz.Height + 2 * pad);
                        g.FillRectangle(brBg2, box2);
                        g.DrawString(txt, fontLbl, brText, box2.X + pad, box2.Y + pad);
                    }
                }
            }
        }

    }

}