936 lines
45 KiB
C#
936 lines
45 KiB
C#
using AgroBase.Comum;
|
|
using AgroBase.Forms.Atuador;
|
|
using AgroBase.Models;
|
|
using AgroBase.Models.Modules;
|
|
using AgroBase.Services;
|
|
using CefSharp;
|
|
using CefSharp.WinForms;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Management;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Windows.Forms.DataVisualization.Charting;
|
|
using static AgroBase.Models.Enuns;
|
|
|
|
namespace AgroBase.Forms.Operacoes
|
|
{
|
|
public partial class frmOperacaoMapaGPS : Form
|
|
{
|
|
private Timer tmrLeituras = new Timer() { Interval = 200 };
|
|
|
|
#region Eventos do formulário
|
|
|
|
public frmOperacaoMapaGPS()
|
|
{
|
|
InitializeComponent();
|
|
|
|
// Ativa o double buffering
|
|
this.DoubleBuffered = true;
|
|
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
|
|
this.SetStyle(ControlStyles.UserPaint, true);
|
|
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
|
|
|
|
pnlAtuadores.GetType().GetMethod("SetStyle", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(pnlAtuadores, new object[] { ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true });
|
|
pnlCaminho.GetType().GetMethod("SetStyle", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(pnlCaminho, new object[] { ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true });
|
|
pnlInclinacao.GetType().GetMethod("SetStyle", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(pnlInclinacao, new object[] { ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true });
|
|
pnlAnguloCamera.GetType().GetMethod("SetStyle", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(pnlAnguloCamera, new object[] { ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true });
|
|
pnlOrientacao.GetType().GetMethod("SetStyle", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(pnlOrientacao, new object[] { ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true });
|
|
|
|
}
|
|
|
|
private void frmOperacaoMapaGPS_Load(object sender, EventArgs e)
|
|
{
|
|
tmrLeituras.Tick += TmrLeituras_Tick;
|
|
tmrLeituras.Start();
|
|
|
|
AtualizarDispositivos();
|
|
AtualizaListaCameras();
|
|
nudPressaoSP.Value = Convert.ToInt32(Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora.PressaoSP);
|
|
}
|
|
|
|
private void frmOperacaoMapaGPS_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
tmrLeituras.Stop();
|
|
Variaveis.OperacaoEmAndamento.CamerasSolo.ForEach(Camera =>
|
|
{
|
|
DesligarCameraSolo(Camera);
|
|
});
|
|
DesligarCameraCaminho(Variaveis.OperacaoEmAndamento.CameraCaminho);
|
|
Variaveis.OperacaoEmAndamento.FinalizarOperacao();
|
|
}
|
|
|
|
private void AtualizarDispositivos()
|
|
{
|
|
chbMOVativo.Checked = Variaveis.OperacaoEmAndamento.DispMov != null && Variaveis.OperacaoEmAndamento.DispMov._Porta.IsOpen;
|
|
chbDIRativo.Checked = Variaveis.OperacaoEmAndamento.DispDir != null && Variaveis.OperacaoEmAndamento.DispDir._Porta.IsOpen;
|
|
chbATUativo.Checked = Variaveis.OperacaoEmAndamento.DispAtu != null && Variaveis.OperacaoEmAndamento.DispAtu._Porta.IsOpen;
|
|
chbGPSativo.Checked = GPSService.PortaGPS != null && GPSService.PortaGPS.IsOpen;
|
|
|
|
AtualizarGrafico();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Rotinas e Atualizações de tela
|
|
|
|
private void TmrLeituras_Tick(object sender, EventArgs e)
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.CamerasSolo.Where(x => x.Iniciada).ToList().ForEach(CameraSolo =>
|
|
{
|
|
try
|
|
{
|
|
AtualizaLeituraCameraSolo(CameraSolo);
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
});
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ErvasNoRadar = Variaveis.OperacaoEmAndamento.CamerasSolo.Sum(x => x.ErvasNoRadar);
|
|
|
|
try
|
|
{
|
|
AtualizaLeituraCameraCaminho();
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
var StatusCarro = Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.StatusAtual;
|
|
if (StatusCarro == StatusCarroMapa.Direcionando)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Mapa.GerarCaminhoEntreDoisPontos(Variaveis.OperacaoEmAndamento.Mapa.Trajetoria[Variaveis.OperacaoEmAndamento.Mapa.IdxRuaAtual].First());
|
|
}
|
|
else if (StatusCarro == StatusCarroMapa.Manobrando)
|
|
{
|
|
//Variaveis.OperacaoEmAndamento.Mapa.GerarCaminhoEntreDoisPontos(Variaveis.OperacaoEmAndamento.Mapa.Trajetoria[Variaveis.OperacaoEmAndamento.Mapa.IdxRuaAtual].First());
|
|
}
|
|
else
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Mapa.TrajetoriaDinamica.Any())
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Mapa.TrajetoriaDinamica.Clear();
|
|
GPSService.AtualizarTrajetoriaDinamica();
|
|
}
|
|
}
|
|
}
|
|
/*else
|
|
{
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.AtualizarRuasSelecionadas();
|
|
}*/
|
|
AtualizarGrafico();
|
|
AtualizarInformacoesGerais();
|
|
pnlOrientacao.Invalidate();
|
|
pnlInclinacao.Invalidate();
|
|
pnlAtuadores.Invalidate();
|
|
|
|
btnCarregarMapa.Enabled = !Variaveis.OperacaoEmAndamento.Iniciado;
|
|
nudPressaoSP.Enabled = !Variaveis.OperacaoEmAndamento.Iniciado;
|
|
|
|
if (!Variaveis.OperacaoEmAndamento.Iniciado && btnIniciarOperacao.Text == "Finalizar Operação")
|
|
{
|
|
AtualizaComponentesOperacao();
|
|
}
|
|
}
|
|
|
|
private void AtualizaLeituraCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
if (CameraSolo.camera._mqttTopico != null && CameraSolo.camera._mqttTopico.Mensagens.Any(x => x.Momento > CameraSolo.camera.IniciadoEm))
|
|
{
|
|
try
|
|
{
|
|
var Mensagem = CameraSolo.camera._mqttTopico.Mensagens.LastOrDefault(x => x.Momento > CameraSolo.camera.IniciadoEm);
|
|
if (Mensagem != null)
|
|
{
|
|
CameraSolo.Leitura = JsonConvert.DeserializeObject<CameraCoordenadasFrameModel>(Mensagem.Mensagem);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
var Atuador = Variaveis.OperacaoEmAndamento.DispAtu;
|
|
|
|
int BicosPorCamera = Atuador.Dados.QuantidadeBicos / Variaveis.OperacaoEmAndamento.CamerasSolo.Count();
|
|
var Verdes = CameraSolo.Leitura.objetos.ToList();
|
|
int intervaloPorBico = Convert.ToInt32(CameraSolo.Leitura.x_max) / BicosPorCamera;
|
|
int inicioBarraPulverizadora = Convert.ToInt32(CameraSolo.Leitura.y_max * (1 - Atuador.Dados.PercentualInicioPulverizacao));
|
|
|
|
List<bool> BicosAnteriores = new List<bool>();
|
|
// Inicialize todos os bicos como inativos antes de verificar os objetos verdes
|
|
for (int i = 0; i < BicosPorCamera; i++)
|
|
{
|
|
int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
|
|
BicosAnteriores.Add(Atuador.Dados.BicosPulverizadores[iBico].Atuado ? true : false);
|
|
Atuador.Dados.BicosPulverizadores[iBico].Atuado = false;
|
|
}
|
|
|
|
foreach (var verde in Verdes)
|
|
{
|
|
// Calcule a posição final (y + altura) do objeto verde
|
|
int posicaoFinalVerdeY = verde.y + verde.altura;
|
|
if (posicaoFinalVerdeY > inicioBarraPulverizadora)
|
|
{
|
|
// Calcule a posição final (x + largura) do objeto verde
|
|
int posicaoFinalVerdeX = verde.x + verde.largura;
|
|
|
|
// Para cada objeto verde, verifique se ele está dentro do intervalo de algum bico e atue-o
|
|
for (int i = 0; i < BicosPorCamera; i++)
|
|
{
|
|
// Determina o intervalo no eixo x para o bico atual
|
|
int limiteInferior = intervaloPorBico * i;
|
|
int limiteSuperior = limiteInferior + intervaloPorBico;
|
|
|
|
// Verifica se o objeto 'verde' está dentro do intervalo deste bico
|
|
// A condição foi ajustada para verificar se qualquer parte do objeto verde cruza com o intervalo do bico
|
|
if (verde.x < limiteSuperior && posicaoFinalVerdeX > limiteInferior)
|
|
{
|
|
int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
|
|
Atuador.Dados.BicosPulverizadores[iBico].Atuado = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CameraSolo.ErvasNoRadar = Verdes.Count();
|
|
|
|
for (int i = 0; i < BicosPorCamera; i++)
|
|
{
|
|
int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
|
|
if (Atuador.Dados.BicosPulverizadores[iBico].Atuado && BicosAnteriores[i] != Atuador.Dados.BicosPulverizadores[iBico].Atuado)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico[iBico]++;
|
|
}
|
|
}
|
|
|
|
lblUltimaLeituraSolo.Text = "Ultima Leitura Solo: " + FuncoesGlobais.TimestampToDate(CameraSolo.Leitura.timestamp);
|
|
|
|
AtualizaInformacoesControleOperacao();
|
|
}
|
|
}
|
|
|
|
private void AtualizaLeituraCameraCaminho()
|
|
{
|
|
try
|
|
{
|
|
var cameraCaminho = Variaveis.OperacaoEmAndamento.CameraCaminho;
|
|
var MqttTopico = Variaveis.MqttService.Topicos.FirstOrDefault(x => x.Topico == cameraCaminho.MqttTopico);
|
|
if (MqttTopico != null && MqttTopico.Mensagens.Any(x => x.Momento > cameraCaminho.camera.IniciadoEm))
|
|
{
|
|
try
|
|
{
|
|
var Mensagem = MqttTopico.Mensagens.LastOrDefault(x => x.Momento > cameraCaminho.camera.IniciadoEm);
|
|
if (Mensagem != null)
|
|
{
|
|
cameraCaminho.Leitura = JsonConvert.DeserializeObject<CameraDeepLabV3PlusModel>(Mensagem.Mensagem);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
//var contornosJson = File.ReadAllText("Python/Output/" + cameraCaminho.ArquivoLeitura);
|
|
//cameraCaminho.Leituras = JsonConvert.DeserializeObject<CameraDeepLabV3PlusModel[]>(contornosJson).ToList();
|
|
|
|
|
|
pnlCaminho.Invalidate();
|
|
|
|
if (cameraCaminho.PontosExtremos.Any())
|
|
{
|
|
double esq_CA = cameraCaminho.PontosExtremos[2].X - cameraCaminho.PontosExtremos[1].X;
|
|
double esq_CO = cameraCaminho.PontosExtremos[1].Y - cameraCaminho.PontosExtremos[2].Y;
|
|
double esq_AG = Math.Atan(esq_CO / esq_CA) * (180 / Math.PI);
|
|
|
|
double dir_CA = cameraCaminho.PontosExtremos[4].X - cameraCaminho.PontosExtremos[3].X;
|
|
double dir_CO = cameraCaminho.PontosExtremos[4].Y - cameraCaminho.PontosExtremos[3].Y;
|
|
double dir_AG = Math.Atan(dir_CO / dir_CA) * (180 / Math.PI);
|
|
|
|
cameraCaminho.Angulo = dir_AG - esq_AG;
|
|
cameraCaminho.AnguloDireito = dir_AG;
|
|
cameraCaminho.AnguloEsquerdo = esq_AG;
|
|
}
|
|
else
|
|
{
|
|
cameraCaminho.Angulo = 0;
|
|
cameraCaminho.AnguloDireito = 0;
|
|
cameraCaminho.AnguloEsquerdo = 0;
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AnguloRuaCamera = cameraCaminho.Angulo;
|
|
|
|
pnlAnguloCamera.Invalidate();
|
|
|
|
lblUltimaLeituraRua.Text = "Ultima Leitura Rua: " + FuncoesGlobais.TimestampToDate(cameraCaminho.Leitura.timestamp);
|
|
|
|
AtualizaInformacoesControleOperacao();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao receber dados da Camera Caminho: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private void AtualizaInformacoesControleOperacao()
|
|
{
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.AtualizarControleAtuadores();
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.CalculaDadosMovimentacaoAutonoma();
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.AtualizarDadosControle();
|
|
}
|
|
|
|
private void AtualizarGrafico()
|
|
{
|
|
MovSensorimanetoGrafico Log = null;
|
|
|
|
var Motor = Variaveis.OperacaoEmAndamento.DispMov.Dados.Motores.FirstOrDefault(x => x.ID == "ET" && x.LogGrafico.Any());
|
|
|
|
if (Motor.LogGrafico.Count > 0)
|
|
{
|
|
Log = Motor.LogGrafico.Last();
|
|
}
|
|
|
|
double Minimo = 0;
|
|
double Maximo = 0;
|
|
|
|
Chart chart = chartGraficos;
|
|
chart.Titles.Clear();
|
|
chart.Titles.Add("Acompanhamento");
|
|
var Logs = (Motor.LogGrafico.Count > MovimentacaoModel.LogsManter ? Motor.LogGrafico.Skip(Math.Max(0, Motor.LogGrafico.Count - MovimentacaoModel.LogsManter)).Take(MovimentacaoModel.LogsManter).ToList() : Motor.LogGrafico).Where(log => log.ComponenteID == Motor.ID).ToList();
|
|
chart.Series.Clear();
|
|
List<string> Momentos = Logs.Select(x => x.Momento.ToString("mm:ss:fff")).ToList();
|
|
|
|
var serieVelocidade = new Series("Velocidade: " + (Log != null ? Log.Velocidade : 0));
|
|
serieVelocidade.Points.DataBindXY(Momentos, Logs.Select(x => x.Velocidade).ToList());
|
|
serieVelocidade.ChartType = SeriesChartType.Line;
|
|
chart.Series.Add(serieVelocidade);
|
|
Minimo = Logs.Min(x => x.Velocidade) < Minimo ? Logs.Min(x => x.Velocidade) : Minimo;
|
|
Maximo = Logs.Min(x => x.Velocidade) > Maximo ? Logs.Min(x => x.Velocidade) : Maximo;
|
|
|
|
var serieRPMsp = new Series("RPM SP: " + (Log != null ? Log.RPM_SP : 0));
|
|
serieRPMsp.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM_SP).ToList());
|
|
serieRPMsp.ChartType = SeriesChartType.Spline;
|
|
chart.Series.Add(serieRPMsp);
|
|
Minimo = Logs.Min(x => x.RPM_SP) < Minimo ? Logs.Min(x => x.RPM_SP) : Minimo;
|
|
Maximo = Logs.Max(x => x.RPM_SP) > Maximo ? Logs.Max(x => x.RPM_SP) : Maximo;
|
|
|
|
var seriePotencia = new Series("Potencia: " + (Log != null ? Log.Potencia : 0));
|
|
seriePotencia.Points.DataBindXY(Momentos, Logs.Select(x => x.Potencia).ToList());
|
|
seriePotencia.ChartType = SeriesChartType.Line;
|
|
chart.Series.Add(seriePotencia);
|
|
Minimo = Logs.Min(x => x.Potencia) < Minimo ? Logs.Min(x => x.Potencia) : Minimo;
|
|
Maximo = Logs.Max(x => x.Potencia) > Maximo ? Logs.Max(x => x.Potencia) : Maximo;
|
|
|
|
var serieTemperatura = new Series("Temperatura: " + (Log != null ? Log.Temperatura : 0));
|
|
serieTemperatura.Points.DataBindXY(Momentos, Logs.Select(x => x.Temperatura).ToList());
|
|
serieTemperatura.ChartType = SeriesChartType.Line;
|
|
chart.Series.Add(serieTemperatura);
|
|
Minimo = Logs.Min(x => x.Temperatura) < Minimo ? Logs.Min(x => x.Temperatura) : Minimo;
|
|
Maximo = Logs.Max(x => x.Temperatura) > Maximo ? Logs.Max(x => x.Temperatura) : Maximo;
|
|
|
|
foreach (var legend in chart.Legends)
|
|
{
|
|
legend.Docking = Docking.Bottom;
|
|
}
|
|
|
|
chart.ChartAreas[0].AxisY.Minimum = Minimo - 5;
|
|
chart.ChartAreas[0].AxisY.Maximum = Maximo + 5;
|
|
}
|
|
|
|
private void AtualizarInformacoesGerais()
|
|
{
|
|
this.Text = Variaveis.OperacaoEmAndamento.TextoFormOperacao("Mapa GPS");
|
|
|
|
//lblDistanciaEsquerda.Text = "Distancia da Esquerda: " + Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaEsquerda.ToString("0.00") + " cm";
|
|
//lblDistanciaDireita.Text = "Distancia da Direita: " + Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaDireita.ToString("0.00") + " cm";
|
|
|
|
lblDistanciaPercorrida.Text = "Distancia Percorrida: " + Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaPercorrida.Sum().ToString("0.00") + " m";
|
|
lblTempoOperacao.Text = "Tempo de Operação: " + Variaveis.OperacaoEmAndamento.Tempo.Hours.ToString("00") + ":" + Variaveis.OperacaoEmAndamento.Tempo.Minutes.ToString("00") + ":" + Variaveis.OperacaoEmAndamento.Tempo.Seconds.ToString("00");
|
|
lblVelocidadeMedia.Text = "Velocidade Média: " + Variaveis.OperacaoEmAndamento.Sensoriamento.VelocidadeMedia.ToString("0.00") + " km/h";
|
|
lblErvasIdentificadas.Text = "Ervas Identificadas: " + Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ErvasIdentificadas.ToString("000");
|
|
lblHerbicidaAplicado.Text = "Herbicida Aplicado: " + Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.HerbicidaConsumido.ToString("0.000") + " L";
|
|
lblHerbicidaPorErva.Text = "Herbicida por Erva: " + Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.HerbicidaPorErva.ToString("0.000") + " mL";
|
|
lblBateriaConsumida.Text = "Bateria Consumida: " + Variaveis.OperacaoEmAndamento.Sensoriamento.BateriaConsumida.ToString("0.00") + "%";
|
|
|
|
lblPressao.Text = "P: " + Variaveis.OperacaoEmAndamento.DispAtu.Dados.PressaoLinha.ToString("0.00") + " psi";
|
|
|
|
FuncoesGlobais.PreencheValorProgressBar(pgbReservatorio, Variaveis.OperacaoEmAndamento.DispAtu.Dados.PercentualReservatorio);
|
|
lblPorcentagemReservatorio.Text = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VolumeReservatorio.ToString("0.000") + " L " + Variaveis.OperacaoEmAndamento.DispAtu.Dados.PercentualReservatorio.ToString("00.00") + "%";
|
|
|
|
FuncoesGlobais.PreencheValorProgressBar(pgbBateria, Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria);
|
|
lblPorcentagemBateria.Text = (PZEMService.Iniciado && PZEMService.UltimaLeitura != null ? PZEMService.UltimaLeitura.Tensao.ToString("0.00") + "v " + PZEMService.UltimaLeitura.Corrente.ToString("0.00") + "A " : "") + Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria.ToString("00.00") + "%";
|
|
|
|
FuncoesGlobais.PreencheValorProgressBar(pgbProgresso, Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ProgressoTrajeto);
|
|
lblPorcentagemProgresso.Text = Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ProgressoTrajeto.ToString("00.00") + "%";
|
|
FuncoesGlobais.PreencheValorProgressBar(pgbProgressoRua, Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ProgressoRua);
|
|
lblPorcentagemProgressoRua.Text = Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ProgressoRua.ToString("00.00") + "%";
|
|
lblDistancia.Text = "Distância Operação: " + (Variaveis.OperacaoEmAndamento.Mapa == null ? 0 : Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal).ToString("00.00") + " m";
|
|
|
|
|
|
AtualizarDadosPerformance();
|
|
}
|
|
|
|
PerformanceCounter cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
|
|
PerformanceCounter ramCounter = new PerformanceCounter("Memory", "Available MBytes");
|
|
DateTime UltimaLeituraCPU = DateTime.Now;
|
|
float cpuUsage = 0;
|
|
public void AtualizarDadosPerformance()
|
|
{
|
|
// Obter memória total
|
|
ObjectQuery wql = new ObjectQuery("SELECT * FROM Win32_ComputerSystem");
|
|
ManagementObjectSearcher searcher = new ManagementObjectSearcher(wql);
|
|
ManagementObjectCollection results = searcher.Get();
|
|
|
|
double totalMemory = 0;
|
|
foreach (ManagementObject result in results)
|
|
{
|
|
totalMemory = Convert.ToDouble(result["TotalPhysicalMemory"]);
|
|
}
|
|
|
|
// Convertendo para MB
|
|
totalMemory = totalMemory / 1024 / 1024;
|
|
float availableMemory = ramCounter.NextValue();
|
|
float usedMemory = (float)totalMemory - availableMemory;
|
|
|
|
// CPU
|
|
if (DateTime.Now > UltimaLeituraCPU.AddSeconds(1))
|
|
{
|
|
cpuUsage = cpuCounter.NextValue();
|
|
UltimaLeituraCPU = DateTime.Now;
|
|
}
|
|
|
|
// RAM (usando o cálculo de porcentagem descrito anteriormente)
|
|
float memoryUsagePercentage = (usedMemory / (float)totalMemory) * 100;
|
|
|
|
// Atualizando o label (GPU não incluído devido à complexidade)
|
|
lblPerformance.Text = $"GPU: {1.ToString("0.0")}% CPU: {cpuUsage.ToString("0.0")}% RAM: {memoryUsagePercentage.ToString("0.0")}%";
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Seleção de câmeras
|
|
|
|
ComboBox cmbCameraCaminho = new ComboBox() { Name = "cmbCameraCaminho", Visible = false };
|
|
ComboBox cmbCameraSoloD = new ComboBox() { Name = "cmbCameraSoloD", Visible = false };
|
|
ComboBox cmbCameraSoloE = new ComboBox() { Name = "cmbCameraSoloE", Visible = false };
|
|
|
|
private void AtualizaListaCameras()
|
|
{
|
|
cmbCameraCaminho.SelectedIndexChanged -= cmbCameraCaminho_SelectedIndexChanged;
|
|
cmbCameraCaminho.SelectedIndexChanged += cmbCameraCaminho_SelectedIndexChanged;
|
|
cmbCameraSoloD.SelectedIndexChanged -= cmbCameraSolo_SelectedIndexChanged;
|
|
cmbCameraSoloD.SelectedIndexChanged += cmbCameraSolo_SelectedIndexChanged;
|
|
cmbCameraSoloE.SelectedIndexChanged -= cmbCameraSolo_SelectedIndexChanged;
|
|
cmbCameraSoloE.SelectedIndexChanged += cmbCameraSolo_SelectedIndexChanged;
|
|
gpbOpcoes.Controls.Add(cmbCameraCaminho);
|
|
gpbOpcoes.Controls.Add(cmbCameraSoloE);
|
|
gpbOpcoes.Controls.Add(cmbCameraSoloD);
|
|
|
|
var listaCameras = CameraService.AtualizaListaCameras().Values.ToArray();
|
|
|
|
var cameras = gpbOpcoes.Controls.OfType<ComboBox>().Where(x => x.Name.Contains("cmbCameraSolo")).OrderBy(x => x.TabIndex).ToList();
|
|
foreach (ComboBox cmb in cameras)
|
|
{
|
|
string CamNome = cmb.Name.Replace("cmbCameraSolo", "");
|
|
CameraSoloModel CameraSolo = Variaveis.OperacaoEmAndamento.CamerasSolo.FirstOrDefault(x => x.Nome == CamNome);
|
|
if (CameraSolo == null)
|
|
{
|
|
CameraSolo = new CameraSoloModel()
|
|
{
|
|
Nome = CamNome,
|
|
Posicao = Variaveis.OperacaoEmAndamento.CamerasSolo.Count(),
|
|
ArquivoLeitura = "ervas_" + CamNome + ".json",
|
|
browser = null,
|
|
camera = new CameraService(),
|
|
CameraSelecionada = "",
|
|
MaxLeituras = 10,
|
|
VideoPorta = (VariaveisPortas.CameraSolo + Variaveis.OperacaoEmAndamento.CamerasSolo.Count()).ToString(),
|
|
VideoUrl = "green_objects_" + CamNome,
|
|
MqttTopico = "green_objects_" + CamNome,
|
|
};
|
|
Variaveis.OperacaoEmAndamento.CamerasSolo.Add(CameraSolo);
|
|
}
|
|
|
|
CameraSolo.combo = cmb;
|
|
CameraSolo.panel = pnlCameraSolo.Controls.OfType<Panel>().Where(x => x.Name.Replace("pnl", "cmb") == cmb.Name).FirstOrDefault();
|
|
|
|
CameraSolo.combo.Items.Clear();
|
|
CameraSolo.combo.Items.AddRange(listaCameras);
|
|
if (CamNome == "D")
|
|
{
|
|
CameraSolo.combo.SelectedIndex = CameraSolo.combo.Items.IndexOf(Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraID_SoloD);
|
|
}
|
|
else if (CamNome == "E")
|
|
{
|
|
CameraSolo.combo.SelectedIndex = CameraSolo.combo.Items.IndexOf(Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraID_SoloE);
|
|
}
|
|
else
|
|
{
|
|
CameraSolo.combo.SelectedIndex = CameraSolo.camera.selectedCamera;
|
|
}
|
|
}
|
|
|
|
if (Variaveis.OperacaoEmAndamento.CameraCaminho == null)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.CameraCaminho = new CameraCaminhoModel()
|
|
{
|
|
Nome = "Caminho",
|
|
Posicao = 0,
|
|
ArquivoLeitura = "leitura_ruas.json",
|
|
browser = null,
|
|
camera = new CameraService(),
|
|
CameraSelecionada = "",
|
|
combo = cmbCameraCaminho,
|
|
MaxLeituras = 1,
|
|
VideoPorta = (VariaveisPortas.CameraCaminho + 0).ToString(),
|
|
VideoUrl = "street_detector",
|
|
MqttTopico = "street_detector",
|
|
panel = pnlCameraCaminho,
|
|
Angulo = 0,
|
|
AnguloDireito = 0,
|
|
AnguloEsquerdo = 0,
|
|
Leitura = new CameraDeepLabV3PlusModel(),
|
|
PontosExtremos = new List<Point>()
|
|
};
|
|
}
|
|
|
|
cmbCameraCaminho.Items.Clear();
|
|
cmbCameraCaminho.Items.AddRange(listaCameras);
|
|
cmbCameraCaminho.SelectedIndex = cmbCameraCaminho.Items.IndexOf(Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraID_Caminho);
|
|
//cmbCameraCaminho.SelectedIndex = Variaveis.OperacaoEmAndamento.CameraCaminho.camera.selectedCamera;
|
|
}
|
|
|
|
private void cmbCameraSolo_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
ComboBox cmb = (ComboBox)sender;
|
|
|
|
string CamNome = cmb.Name.Replace("cmbCameraSolo", "");
|
|
|
|
CameraSoloModel CameraSolo = Variaveis.OperacaoEmAndamento.CamerasSolo.FirstOrDefault(x => x.Nome == CamNome);
|
|
|
|
if (CameraSolo.combo.SelectedIndex > 0 && (cmbCameraCaminho.SelectedIndex == CameraSolo.combo.SelectedIndex || Variaveis.OperacaoEmAndamento.CamerasSolo.Any(x => x.Nome != CameraSolo.Nome && x.combo.SelectedIndex == CameraSolo.combo.SelectedIndex)))
|
|
{
|
|
MessageBox.Show("Essa câmera já está sendo usada por outro processo!", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
CameraSolo.combo.SelectedIndex = CameraSolo.camera.selectedCamera;
|
|
return;
|
|
}
|
|
|
|
CameraSolo.camera.selectedCamera = CameraSolo.combo.SelectedIndex;
|
|
DesligarCameraSolo(CameraSolo);
|
|
if (CameraSolo.camera.selectedCamera > 0)
|
|
{
|
|
IniciarCameraSolo(CameraSolo);
|
|
}
|
|
CameraSolo.CameraSelecionada = CameraSolo.combo.Text;
|
|
}
|
|
|
|
private void IniciarCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
CameraSolo.camera.IniciarCamera(
|
|
Variaveis.OperacaoEmAndamento.DispAtu.Dados.ScriptDeteccaoErvas,
|
|
new string[] {
|
|
CameraSolo.MaxLeituras.ToString(),
|
|
CameraSolo.VideoPorta,
|
|
CameraSolo.VideoUrl,
|
|
CameraSolo.ArquivoLeitura,
|
|
"1",
|
|
CameraSolo.MqttTopico
|
|
},
|
|
CameraSolo.VideoPorta,
|
|
CameraSolo.VideoUrl,
|
|
CameraSolo.MqttTopico,
|
|
CameraSolo.tmrProcesso
|
|
);
|
|
}
|
|
|
|
private void DesligarCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
CameraSolo.DesligarCamera();
|
|
}
|
|
|
|
|
|
|
|
|
|
private void cmbCameraCaminho_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.CameraCaminho.combo.SelectedIndex > 0 && Variaveis.OperacaoEmAndamento.CamerasSolo.Any(x => x.combo.SelectedIndex == Variaveis.OperacaoEmAndamento.CameraCaminho.combo.SelectedIndex))
|
|
{
|
|
MessageBox.Show("Essa câmera já está sendo usada por outro processo!", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
Variaveis.OperacaoEmAndamento.CameraCaminho.combo.SelectedIndex = Variaveis.OperacaoEmAndamento.CameraCaminho.camera.selectedCamera;
|
|
return;
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.CameraCaminho.camera.selectedCamera = cmbCameraCaminho.SelectedIndex;
|
|
DesligarCameraCaminho(Variaveis.OperacaoEmAndamento.CameraCaminho);
|
|
if (Variaveis.OperacaoEmAndamento.CameraCaminho.camera.selectedCamera > 0)
|
|
{
|
|
IniciarCameraCaminho(Variaveis.OperacaoEmAndamento.CameraCaminho);
|
|
}
|
|
Variaveis.OperacaoEmAndamento.CameraCaminho.CameraSelecionada = cmbCameraCaminho.Text;
|
|
}
|
|
|
|
private void IniciarCameraCaminho(CameraCaminhoModel cameraCaminho)
|
|
{
|
|
cameraCaminho.camera.IniciarCamera(
|
|
PythonService.ScriptStreetDetector,
|
|
new string[] {
|
|
cameraCaminho.MaxLeituras.ToString(),
|
|
cameraCaminho.VideoPorta,
|
|
cameraCaminho.VideoUrl,
|
|
cameraCaminho.ArquivoLeitura,
|
|
"1",
|
|
cameraCaminho.MqttTopico
|
|
},
|
|
cameraCaminho.VideoPorta,
|
|
cameraCaminho.VideoUrl,
|
|
cameraCaminho.MqttTopico,
|
|
cameraCaminho.tmrProcesso
|
|
);
|
|
}
|
|
|
|
private void DesligarCameraCaminho(CameraCaminhoModel cameraCaminho)
|
|
{
|
|
cameraCaminho.DesligarCamera();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Botões
|
|
|
|
private void btnCarregarMapa_Click(object sender, EventArgs e)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Mapa = new MapasModel()
|
|
{
|
|
pnlMapa = pnlMapa,
|
|
lblMapa = lblMapaCarregado,
|
|
};
|
|
Variaveis.OperacaoEmAndamento.Mapa.btnCarregar_Click(sender, e);
|
|
}
|
|
|
|
private void btnIniciarOperacao_Click(object sender, EventArgs e)
|
|
{
|
|
if (btnIniciarOperacao.Text == "Finalizar Operação")
|
|
{
|
|
Variaveis.OperacaoEmAndamento.FinalizarOperacao();
|
|
}
|
|
else
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.OperacaoLiberada && Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal > 0 && Variaveis.OperacaoEmAndamento.Mapa.RuasPercorrer.Any())
|
|
{
|
|
Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora.PressaoSP = Convert.ToDouble(nudPressaoSP.Value);
|
|
Variaveis.OperacaoEmAndamento.IniciarOperacao(null, false);
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Finalize a parametrização corretamente para iniciar a operação!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
AtualizaComponentesOperacao();
|
|
}
|
|
|
|
private void AtualizaComponentesOperacao()
|
|
{
|
|
btnIniciarOperacao.Text = !Variaveis.OperacaoEmAndamento.Iniciado ? "Iniciar Operação" : "Finalizar Operação";
|
|
cmbCameraSoloE.Enabled = !Variaveis.OperacaoEmAndamento.Iniciado;
|
|
cmbCameraSoloD.Enabled = !Variaveis.OperacaoEmAndamento.Iniciado;
|
|
cmbCameraCaminho.Enabled = !Variaveis.OperacaoEmAndamento.Iniciado;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Atualizações dos panels
|
|
|
|
private void pnlAtuadores_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
var Atuador = Variaveis.OperacaoEmAndamento.DispAtu;
|
|
|
|
Graphics g = e.Graphics;
|
|
Panel myPanel = (Panel)sender;
|
|
int panelWidth = myPanel.Width;
|
|
int circleDiameter = 40; // Diâmetro dos círculos grandes
|
|
int smallCircleDiameter = circleDiameter / 2; // Diâmetro dos círculos pequenos
|
|
int spaceBetweenCircles = (panelWidth - (circleDiameter * Atuador.Dados.QuantidadeBicos)) / (Atuador.Dados.QuantidadeBicos + 1);
|
|
int yPosition = (myPanel.Height - circleDiameter) / 3; // Centralizado verticalmente
|
|
|
|
|
|
for (int i = 0; i < Atuador.Dados.QuantidadeBicos; i++)
|
|
{
|
|
// Calcula a posição x do círculo
|
|
int xPosition = spaceBetweenCircles + (i * (circleDiameter + spaceBetweenCircles));
|
|
// Desenha o contorno do círculo
|
|
g.DrawEllipse(Pens.Red, xPosition, yPosition, circleDiameter, circleDiameter);
|
|
// Se o bico estiver aceso, preenche o círculo
|
|
if (Atuador.Dados.BicosPulverizadores[i].Atuado)
|
|
{
|
|
g.FillEllipse(Brushes.Red, xPosition, yPosition, circleDiameter, circleDiameter);
|
|
}
|
|
|
|
// Define a string que representa o número do bico
|
|
string bicoNumero = Atuador.Dados.BicosPulverizadores[i].ID;
|
|
// Define a fonte para o texto
|
|
Font font = new Font("Arial", 10, FontStyle.Bold);
|
|
// Mede o tamanho do texto
|
|
SizeF stringSize = g.MeasureString(bicoNumero, font);
|
|
// Calcula as posições x e y para centralizar o texto no círculo
|
|
float textXPosition = xPosition + (circleDiameter - stringSize.Width) / 2;
|
|
float textYPosition = yPosition + (circleDiameter - stringSize.Height) / 2;
|
|
// Desenha o número do bico
|
|
g.DrawString(bicoNumero, font, Brushes.Black, textXPosition, textYPosition);
|
|
|
|
|
|
// Define a string que representa a atuacao do bico
|
|
string bicoAtuacao = Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico[i].ToString("000");
|
|
// Define a fonte para o texto
|
|
Font fontA = new Font("Arial", 8, FontStyle.Bold);
|
|
// Mede o tamanho do texto
|
|
SizeF stringSizeA = g.MeasureString(bicoAtuacao, fontA);
|
|
// Calcula as posições x e y para centralizar o texto no círculo
|
|
float textXPositionA = xPosition + (circleDiameter - stringSizeA.Width) / 2;
|
|
float textYPositionA = circleDiameter + yPosition + 5;
|
|
// Desenha as atuacoes do bico
|
|
g.DrawString(bicoAtuacao, fontA, Brushes.Black, textXPositionA, textYPositionA);
|
|
|
|
|
|
// Calcula a posição x e y do círculo pequeno
|
|
int smallCircleXPosition = Convert.ToInt32(xPosition + circleDiameter - smallCircleDiameter / 1.3);
|
|
int smallCircleYPosition = Convert.ToInt32(yPosition + circleDiameter - smallCircleDiameter / 1.3);
|
|
|
|
// Define a cor de contorno e preenchimento para o círculo pequeno
|
|
Pen smallCirclePen = Pens.Blue; // Cor do contorno
|
|
Brush smallCircleBrush = Brushes.Transparent; // Cor de preenchimento padrão
|
|
|
|
// Se o status do bico for true, altera a cor de preenchimento para azul
|
|
if (Atuador.Dados.BicosPulverizadores[i].StatusBico)
|
|
{
|
|
smallCircleBrush = Brushes.Blue;
|
|
}
|
|
|
|
// Desenha o contorno do círculo pequeno
|
|
g.DrawEllipse(smallCirclePen, smallCircleXPosition, smallCircleYPosition, smallCircleDiameter, smallCircleDiameter);
|
|
// Preenche o círculo pequeno se o status do bico for true
|
|
g.FillEllipse(smallCircleBrush, smallCircleXPosition, smallCircleYPosition, smallCircleDiameter, smallCircleDiameter);
|
|
}
|
|
}
|
|
|
|
private void pnlCaminho_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
var cameraCaminho = Variaveis.OperacaoEmAndamento.CameraCaminho;
|
|
|
|
Panel pnlContornos = (Panel)sender;
|
|
if (cameraCaminho.Leitura == null) return;
|
|
|
|
Graphics graphics = e.Graphics;
|
|
graphics.Clear(pnlContornos.BackColor); // Limpa o fundo
|
|
|
|
// Determina as dimensões máximas dos contornos
|
|
float larguraMaxContornos = 512; // Substitua pelo valor real
|
|
float alturaMaxContornos = 512; // Substitua pelo valor real
|
|
|
|
// Proporção de escala baseada no tamanho do Panel e nas dimensões dos contornos
|
|
float proporcaoX = pnlContornos.Width / larguraMaxContornos;
|
|
float proporcaoY = pnlContornos.Height / alturaMaxContornos;
|
|
float escala = Math.Min(proporcaoX, proporcaoY); // Mantém a proporção sem distorcer
|
|
|
|
// Calcula o novo tamanho dos contornos após o redimensionamento
|
|
float novaLargura = larguraMaxContornos * escala;
|
|
float novaAltura = alturaMaxContornos * escala;
|
|
|
|
// Calcula o deslocamento para centralizar os contornos no Panel
|
|
float deslocamentoX = (pnlContornos.Width - novaLargura) / 2;
|
|
float deslocamentoY = (pnlContornos.Height - novaAltura) / 2;
|
|
|
|
List<Point> pontosCamera = new List<Point>();
|
|
var Classe = cameraCaminho.ClassMap.FirstOrDefault(x => x.Key == "rua");
|
|
foreach (var cameraClass in cameraCaminho.Leitura.Classes.Where(x => x.Classe == Classe.Key))
|
|
{
|
|
if (cameraClass.Contornos == null || cameraClass.Contornos.Length == 0) continue;
|
|
|
|
using (Pen pen = new Pen(Color.Blue, 2))
|
|
{
|
|
for (int i = 0; i < cameraClass.Contornos.Length - 1; i++)
|
|
{
|
|
Point contorno = new Point() { X = cameraClass.Contornos[i][0], Y = cameraClass.Contornos[i][1] };
|
|
Point contornoP = new Point() { X = cameraClass.Contornos[i + 1][0], Y = cameraClass.Contornos[i + 1][1] };
|
|
|
|
// Aplica a escala e o deslocamento às coordenadas
|
|
Point start = new Point((int)(contorno.X * escala + deslocamentoX), (int)(contorno.Y * escala + deslocamentoY));
|
|
Point end = new Point((int)(contornoP.X * escala + deslocamentoX), (int)(contornoP.Y * escala + deslocamentoY));
|
|
|
|
//graphics.DrawLine(pen, start, end);
|
|
|
|
pontosCamera.Add(contorno);
|
|
}
|
|
|
|
// Se necessário, fechar o contorno conectando o último ponto ao primeiro
|
|
if (cameraClass.Contornos.Length > 1 && false)
|
|
{
|
|
var primeiro = cameraClass.Contornos.First();
|
|
var ultimo = cameraClass.Contornos.Last();
|
|
Point start = new Point((int)(ultimo[0] * escala + deslocamentoX), (int)(ultimo[1] * escala + deslocamentoY));
|
|
Point end = new Point((int)(primeiro[0] * escala + deslocamentoX), (int)(primeiro[1] * escala + deslocamentoY));
|
|
graphics.DrawLine(pen, start, end);
|
|
}
|
|
}
|
|
}
|
|
|
|
using (Pen pen = new Pen(Classe.Value, 2))
|
|
{
|
|
cameraCaminho.PontosExtremos = CameraCaminhoModel.DefinirPontosExtremos(pontosCamera);
|
|
for (int i = 0; i < cameraCaminho.PontosExtremos.Count - 1; i++)
|
|
{
|
|
// Aplica a escala e o deslocamento às coordenadas
|
|
Point start = new Point((int)(cameraCaminho.PontosExtremos[i].X * escala + deslocamentoX), (int)(cameraCaminho.PontosExtremos[i].Y * escala + deslocamentoY));
|
|
Point end = new Point((int)(cameraCaminho.PontosExtremos[i + 1].X * escala + deslocamentoX), (int)(cameraCaminho.PontosExtremos[i + 1].Y * escala + deslocamentoY));
|
|
|
|
graphics.DrawLine(pen, start, end);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void pnlInclinacao_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
//DesenharInclinacao((Panel)sender, e, (float)cameraCaminho.Angulo);
|
|
DesenharInclinacao((Panel)sender, e, (float)(Variaveis.OperacaoEmAndamento.OpMapaGPS.Controle.Angulo), 90);
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
private void pnlAnguloCamera_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
//DesenharInclinacao((Panel)sender, e, (float)cameraCaminho.Angulo);
|
|
DesenharInclinacao((Panel)sender, e, (float)(Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AnguloRuaCamera), 90);
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
private void pnlOrientacao_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
double angulo = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloCarro;
|
|
DesenharInclinacao((Panel)sender, e, (float)angulo, -90);
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
private void DesenharInclinacao(Panel pnlBussola, PaintEventArgs e, float anguloInclinacao, float anguloSub)
|
|
{
|
|
if (!(anguloInclinacao >= 0 || anguloInclinacao <= 0))
|
|
{
|
|
anguloInclinacao = 0;
|
|
}
|
|
|
|
Graphics g = e.Graphics;
|
|
// Desenha o círculo da bússola
|
|
int diameter = Math.Min(pnlBussola.Width - 1, pnlBussola.Height - 1);
|
|
Point centro = new Point((pnlBussola.Width - 1) / 2, (pnlBussola.Height - 1) / 2);
|
|
//g.DrawEllipse(Pens.Black, centro.X - diameter / 2, centro.Y - diameter / 2, diameter, diameter);
|
|
|
|
// Escreve o ângulo no centro do círculo
|
|
string anguloTexto = $"{anguloInclinacao.ToString("0")}°";
|
|
Font fonteAngulo = new Font("Arial", 7); // Ajuste o tamanho da fonte conforme necessário
|
|
SizeF textSize = e.Graphics.MeasureString(anguloTexto, fonteAngulo);
|
|
|
|
// Calcula a posição para o texto ser centralizado no círculo
|
|
float textX = 0;
|
|
float textY = 0;
|
|
|
|
// Define a cor do texto
|
|
Brush textBrush = Brushes.Black;
|
|
|
|
// Desenha o texto no Graphics do painel
|
|
g.DrawString(anguloTexto, fonteAngulo, textBrush, textX, textY);
|
|
|
|
// A linha será desenhada do centro do círculo
|
|
PointF pontoCentral = new PointF(centro.X, centro.Y);
|
|
// O comprimento da linha será metade do diâmetro do círculo (raio)
|
|
float comprimentoLinha = diameter / 3;
|
|
|
|
// Ajustar o ângulo para que 0 graus esteja para cima e aumente no sentido horário
|
|
//float anguloRadianos = (anguloInclinacao - 90) * (float)(Math.PI / 180.0);
|
|
float anguloRadianos = (anguloInclinacao - anguloSub) * (float)(Math.PI / 180.0);
|
|
|
|
// Calcular o ponto final da linha baseado no ângulo de inclinação
|
|
PointF pontoFinal = new PointF(
|
|
pontoCentral.X + comprimentoLinha * (float)Math.Cos(anguloRadianos),
|
|
pontoCentral.Y + comprimentoLinha * (float)Math.Sin(anguloRadianos)
|
|
);
|
|
|
|
// Desenhar a linha de inclinação
|
|
g.DrawLine(Pens.Red, pontoCentral, pontoFinal);
|
|
|
|
// Opcional: Desenhar uma ponta de seta na linha para indicar direção
|
|
using (AdjustableArrowCap bigArrow = new AdjustableArrowCap(4, 4))
|
|
{
|
|
using (Pen pen = new Pen(Color.Red, 2))
|
|
{
|
|
pen.CustomEndCap = bigArrow;
|
|
g.DrawLine(pen, pontoCentral, pontoFinal);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
|
|
#region SIMULACAO GPS
|
|
|
|
private void btnSimular_Click(object sender, EventArgs e)
|
|
{
|
|
GPSService.SimularGPS();
|
|
Timer tmr = new Timer() { Interval = 500 };
|
|
tmr.Tick += Tmr_Tick;
|
|
tmr.Start();
|
|
}
|
|
|
|
private void Tmr_Tick(object sender, EventArgs e)
|
|
{
|
|
if (!GPSService.Iniciado)
|
|
{
|
|
((Timer)sender).Stop();
|
|
}
|
|
lblStatus.Text = "Status: " + Enum.GetName(typeof(StatusCarroMapa), Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.StatusAtual);
|
|
lblDirecao.Text = "Direção: " + Enum.GetName(typeof(DirecaoCarroRua), Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.Direcao);
|
|
//var Ponto = Variaveis.OperacaoEmAndamento.Mapa.Trajetoria[Variaveis.OperacaoEmAndamento.Mapa.IdxRuaAtual][Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.IdxPontoAproximadoRua];
|
|
}
|
|
|
|
private void btnManobraConcluida_Click(object sender, EventArgs e)
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.StatusAtual == StatusCarroMapa.Manobrando)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.ManobraConcluida = true;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
}
|
|
}
|