930 lines
43 KiB
C#
930 lines
43 KiB
C#
using AgroBase.Comum;
|
|
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.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.IO;
|
|
using System.Linq;
|
|
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
|
|
{
|
|
#region Variáveis
|
|
|
|
private List<CameraSoloModel> CamerasSolo = new List<CameraSoloModel>();
|
|
|
|
private CameraCaminhoModel cameraCaminho;
|
|
|
|
private Timer tmrLeituras = new Timer() { Interval = 200 };
|
|
|
|
DispositivosService<MovimentacaoModel> Movimentacao;
|
|
DispositivosService<DirecionalModel> Direcional;
|
|
DispositivosService<AtuadorModel> Atuador;
|
|
|
|
#endregion
|
|
|
|
#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 });
|
|
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();
|
|
|
|
Variaveis.OperacaoEmAndamento = new OperacaoModel(ModoOperacao.MapaGPS, Movimentacao, Direcional, Atuador);
|
|
}
|
|
|
|
private void frmOperacaoMapaGPS_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
tmrLeituras.Stop();
|
|
//DesligarCameraSoloE();
|
|
CamerasSolo.ForEach(Camera =>
|
|
{
|
|
DesligarCameraSolo(Camera);
|
|
});
|
|
DesligarCameraCaminho();
|
|
Variaveis.OperacaoEmAndamento.FinalizarOperacao();
|
|
}
|
|
|
|
private void AtualizarDispositivos()
|
|
{
|
|
Movimentacao = (DispositivosService<MovimentacaoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Mov);
|
|
Direcional = (DispositivosService<DirecionalModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Dir);
|
|
Atuador = (DispositivosService<AtuadorModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Atu);
|
|
|
|
chbMOVativo.Checked = Movimentacao != null && Movimentacao._Porta.IsOpen;
|
|
chbDIRativo.Checked = Direcional != null && Direcional._Porta.IsOpen;
|
|
chbATUativo.Checked = Atuador != null && Atuador._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)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Tempo = TimeSpan.FromTicks(Variaveis.OperacaoEmAndamento.Iniciado ? ((Variaveis.OperacaoEmAndamento.TimestampFim > 0 ? Variaveis.OperacaoEmAndamento.TimestampFim : DateTime.Now.Ticks) - Variaveis.OperacaoEmAndamento.TimestampInicio) : 0);
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
CamerasSolo.ForEach(CameraSolo =>
|
|
{
|
|
AtualizaLeituraCameraSolo(CameraSolo);
|
|
});
|
|
|
|
AtualizaLeituraCameraCaminho();
|
|
|
|
AtualizarGrafico();
|
|
}
|
|
|
|
AtualizarInformacoesGerais();
|
|
|
|
if (!Variaveis.OperacaoEmAndamento.Iniciado && btnIniciarOperacao.Text == "Finalizar Operação")
|
|
{
|
|
AtualizaComponentesOperacao();
|
|
}
|
|
}
|
|
|
|
private void AtualizaLeituraCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
if (CameraSolo.camera.socket != null && CameraSolo.camera.socket.DadosRecebidos.Any())
|
|
{
|
|
int BicosPorCamera = Atuador.Dados.QuantidadeBicos / CamerasSolo.Count();
|
|
var leitura = CameraSolo.camera.socket.DadosRecebidos.Last();
|
|
var Verdes = leitura.objetos.ToList();
|
|
int intervaloPorBico = Convert.ToInt32(CameraSolo.camera.socket.DadosRecebidos.First().x_max) / BicosPorCamera;
|
|
int inicioBarraPulverizadora = Convert.ToInt32(CameraSolo.camera.socket.DadosRecebidos.First().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.Sensoriamento.AtuacoesPorBico[iBico]++;
|
|
}
|
|
}
|
|
|
|
lblUltimaLeituraSolo.Text = "Ultima Leitura Solo: " + FuncoesGlobais.TimestampToDate(leitura.timestamp);
|
|
pnlAtuadores.Invalidate();
|
|
|
|
AtualizaInformacoesControleOperacao();
|
|
}
|
|
}
|
|
|
|
private void AtualizaLeituraCameraCaminho()
|
|
{
|
|
try
|
|
{
|
|
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 = esq_AG - dir_AG;
|
|
cameraCaminho.AnguloDireito = dir_AG;
|
|
cameraCaminho.AnguloEsquerdo = esq_AG;
|
|
}
|
|
else
|
|
{
|
|
cameraCaminho.Angulo = 0;
|
|
cameraCaminho.AnguloDireito = 0;
|
|
cameraCaminho.AnguloEsquerdo = 0;
|
|
}
|
|
|
|
pnlInclinacao.Invalidate();
|
|
|
|
lblUltimaLeituraRua.Text = "Ultima Leitura Rua: " + FuncoesGlobais.TimestampToDate(cameraCaminho.Leituras.FirstOrDefault().timestamp);
|
|
|
|
AtualizaInformacoesControleOperacao();
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
private void AtualizaInformacoesControleOperacao()
|
|
{
|
|
TimeSpan tempo = TimeSpan.FromTicks(DateTime.Now.Ticks - Variaveis.OperacaoEmAndamento.TimestampInicio);
|
|
bool operacaoEmAndamento = tempo.Seconds > Variaveis.OperacaoEmAndamento.TempoIniciarOperacao;
|
|
|
|
|
|
var BicosNaoAtuados = new List<AtuadorBicoModel>();
|
|
Atuador.Dados.BicosPulverizadores.ForEach(x =>
|
|
{
|
|
BicosNaoAtuados.Add(x);
|
|
});
|
|
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.ErvasNoRadar = CamerasSolo.Sum(x => x.ErvasNoRadar);
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.ErvasIdentificadas = Variaveis.OperacaoEmAndamento.Sensoriamento.AtuacoesPorBico.Sum();
|
|
if (!operacaoEmAndamento)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Controle.BicosAtuados = BicosNaoAtuados.ToList();
|
|
Variaveis.OperacaoEmAndamento.Controle.RPM = 0;
|
|
Variaveis.OperacaoEmAndamento.Controle.Angulo = 0;
|
|
}
|
|
else
|
|
{
|
|
Variaveis.OperacaoEmAndamento.CalculaDadosMovimentacaoAutonoma();
|
|
|
|
Variaveis.OperacaoEmAndamento.Controle.BicosAtuados =
|
|
!chbATUativo.Checked ? BicosNaoAtuados
|
|
: Atuador.Dados.BicosPulverizadores;
|
|
Variaveis.OperacaoEmAndamento.Controle.RPM =
|
|
!chbMOVativo.Checked ? 0 :
|
|
!cameraCaminho.PontosExtremos.Any() ? 0 :
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.ErvasNoRadar == 0 ?
|
|
Variaveis.OperacaoEmAndamento.Controle.RPM_Max :
|
|
Variaveis.OperacaoEmAndamento.Controle.RPM_Min;
|
|
Variaveis.OperacaoEmAndamento.Controle.Angulo =
|
|
!chbDIRativo.Checked ? 0 :
|
|
cameraCaminho.Angulo > Variaveis.OperacaoEmAndamento.Controle.Angulo_Max ? Variaveis.OperacaoEmAndamento.Controle.Angulo_Max :
|
|
cameraCaminho.Angulo < Variaveis.OperacaoEmAndamento.Controle.Angulo_Min ? Variaveis.OperacaoEmAndamento.Controle.Angulo_Min :
|
|
cameraCaminho.Angulo;
|
|
}
|
|
|
|
pnlOrientacao.Invalidate();
|
|
|
|
Variaveis.OperacaoEmAndamento.AtualizarDadosControle();
|
|
}
|
|
|
|
private void AtualizarGrafico()
|
|
{
|
|
MovSensorimanetoGrafico Log = null;
|
|
|
|
var Motor = Movimentacao.Dados.Motores.FirstOrDefault(x => 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 serieRPMsp = new Series("Velocidade: " + (Log != null ? Log.Velocidade : 0));
|
|
serieRPMsp.Points.DataBindXY(Momentos, Logs.Select(x => x.Velocidade).ToList());
|
|
serieRPMsp.ChartType = SeriesChartType.Line;
|
|
chart.Series.Add(serieRPMsp);
|
|
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 serieRPM = new Series("RPM: " + (Log != null ? Log.RPM : 0));
|
|
//serieRPM.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM).ToList());
|
|
//serieRPM.ChartType = SeriesChartType.Spline;
|
|
//chart.Series.Add(serieRPM);
|
|
//Minimo = Logs.Min(x => x.RPM) < Minimo ? Logs.Min(x => x.RPM) : Minimo;
|
|
//Maximo = Logs.Max(x => x.RPM) > Maximo ? Logs.Max(x => x.RPM) : 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()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.StatusAtual == StatusOperacao.Parametrizando)
|
|
{
|
|
this.Text = "Operação Seguidor de Linha - Parametrização";
|
|
}
|
|
else if (Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.StatusAtual == StatusOperacao.Aguardando)
|
|
{
|
|
this.Text = "Operação Seguidor de Linha - Iniciando em " + (Variaveis.OperacaoEmAndamento.TempoIniciarOperacao - Variaveis.OperacaoEmAndamento.Tempo.Seconds) + " segundo" + (Variaveis.OperacaoEmAndamento.TempoIniciarOperacao - Variaveis.OperacaoEmAndamento.Tempo.Seconds == 1 ? "" : "s") + "...";
|
|
}
|
|
else if (Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.StatusAtual == StatusOperacao.Concluida)
|
|
{
|
|
this.Text = "Operação Seguidor de Linha - Concluída";
|
|
}
|
|
else if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
this.Text = "Operação Seguidor de Linha - Iniciado";
|
|
}
|
|
|
|
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.Sensoriamento.ErvasIdentificadas.ToString("000");
|
|
lblHerbicidaAplicado.Text = "Herbicida Aplicado: " + Variaveis.OperacaoEmAndamento.Sensoriamento.HerbicidaConsumido.ToString("0.000") + " L";
|
|
lblHerbicidaPorErva.Text = "Herbicida por Erva: " + Variaveis.OperacaoEmAndamento.Sensoriamento.HerbicidaPorErva.ToString("0.000") + " mL";
|
|
lblBateriaConsumida.Text = "Bateria Consumida: " + Variaveis.OperacaoEmAndamento.Sensoriamento.BateriaConsumida.ToString("0.00") + "%";
|
|
|
|
lblPressao.Text = "P: " + Atuador.Dados.PressaoLinha.ToString("0.00") + " psi";
|
|
|
|
pgbReservatorio.Value = Convert.ToInt32(Atuador.Dados.PercentualReservatorio);
|
|
lblPorcentagemReservatorio.Text = Atuador.Dados.PercentualReservatorio.ToString("00.00") + "%";
|
|
|
|
pgbBateria.Value = Convert.ToInt32(Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria);
|
|
lblPorcentagemReservatorio.Text = Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria.ToString("00.00") + "%";
|
|
|
|
pgbProgresso.Value = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoTrajeto <= 100 ? Convert.ToInt32(Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoTrajeto) : 100;
|
|
lblPorcentagemProgresso.Text = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoTrajeto.ToString("00.00") + "%";
|
|
pgbProgressoRua.Value = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoRua <= 100 ? Convert.ToInt32(Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoRua) : 100;
|
|
lblPorcentagemProgressoRua.Text = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoRua.ToString("00.00") + "%";
|
|
lblDistancia.Text = "Distância Operação: " + (Variaveis.OperacaoEmAndamento.Mapa == null ? 0 : Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal).ToString("00.00") + " m";
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Seleção de câmeras
|
|
|
|
private void AtualizaListaCameras()
|
|
{
|
|
var listaCameras = new CameraService<object>().AtualizaListaCameras().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 = CamerasSolo.FirstOrDefault(x => x.Nome == CamNome);
|
|
if (CameraSolo == null)
|
|
{
|
|
CameraSolo = new CameraSoloModel()
|
|
{
|
|
Nome = CamNome,
|
|
Posicao = CamerasSolo.Count(),
|
|
ArquivoLeitura = "ervas_" + CamNome + ".json",
|
|
browser = null,
|
|
camera = new CameraService<CameraCoordenadasFrameModel>(),
|
|
CameraSelecionada = "",
|
|
combo = cmb,
|
|
MaxLeituras = 10,
|
|
SocketPorta = (VariaveisPortas.SocketSolo + CamerasSolo.Count()).ToString(),
|
|
VideoPorta = (VariaveisPortas.CameraSolo + CamerasSolo.Count()).ToString(),
|
|
VideoUrl = "green_objects_" + CamNome,
|
|
panel = pnlCameraSolo.Controls.OfType<Panel>().Where(x => x.Name.Replace("pnl", "cmb") == cmb.Name).FirstOrDefault(),
|
|
};
|
|
CamerasSolo.Add(CameraSolo);
|
|
}
|
|
|
|
CameraSolo.combo.Items.Clear();
|
|
CameraSolo.combo.Items.AddRange(listaCameras);
|
|
if (CameraSolo.combo.Items.Count == 1)
|
|
{
|
|
CameraSolo.camera.selectedCamera = 0;
|
|
}
|
|
CameraSolo.combo.SelectedIndex = CameraSolo.camera.selectedCamera;
|
|
}
|
|
|
|
if (cameraCaminho == null)
|
|
{
|
|
cameraCaminho = new CameraCaminhoModel()
|
|
{
|
|
Nome = "Caminho",
|
|
Posicao = 0,
|
|
ArquivoLeitura = "leitura_ruas.json",
|
|
browser = null,
|
|
camera = new CameraService<CameraDeepLabV3PlusModel>(),
|
|
CameraSelecionada = "",
|
|
combo = cmbCameraCaminho,
|
|
MaxLeituras = 1,
|
|
SocketPorta = (VariaveisPortas.SocketCaminho + 0).ToString(),
|
|
VideoPorta = (VariaveisPortas.CameraCaminho + 0).ToString(),
|
|
VideoUrl = "street_detector",
|
|
panel = pnlCameraCaminho,
|
|
Angulo = 0,
|
|
AnguloDireito = 0,
|
|
AnguloEsquerdo = 0,
|
|
Leituras = new List<CameraDeepLabV3PlusModel>(),
|
|
PontosExtremos = new List<Point>()
|
|
};
|
|
}
|
|
|
|
cameraCaminho.camera.selectedCamera = cmbCameraCaminho.SelectedIndex > 0 ? cmbCameraCaminho.SelectedIndex : 0;
|
|
cmbCameraCaminho.Items.Clear();
|
|
cmbCameraCaminho.Items.AddRange(listaCameras);
|
|
if (cmbCameraCaminho.Items.Count == 1)
|
|
{
|
|
cameraCaminho.camera.selectedCamera = 0;
|
|
}
|
|
cmbCameraCaminho.SelectedIndex = cameraCaminho.camera.selectedCamera;
|
|
}
|
|
|
|
private void cmbCameraSolo_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
ComboBox cmb = (ComboBox)sender;
|
|
|
|
string CamNome = cmb.Name.Replace("cmbCameraSolo", "");
|
|
|
|
CameraSoloModel CameraSolo = CamerasSolo.FirstOrDefault(x => x.Nome == CamNome);
|
|
|
|
if (CameraSolo.CameraSelecionada != "Sem vídeo" && CameraSolo.CameraSelecionada != "")
|
|
{
|
|
cmbCameraCaminho.Items.Add(CameraSolo.CameraSelecionada);
|
|
CamerasSolo.Where(x => x.Nome != CamNome).ToList().ForEach(Camera =>
|
|
{
|
|
Camera.combo.Items.Add(CameraSolo.CameraSelecionada);
|
|
});
|
|
}
|
|
|
|
CameraSolo.camera.selectedCamera = CameraSolo.combo.SelectedIndex;
|
|
DesligarCameraSolo(CameraSolo);
|
|
if (CameraSolo.camera.selectedCamera > 0)
|
|
{
|
|
IniciarCameraSolo(CameraSolo);
|
|
}
|
|
CameraSolo.CameraSelecionada = CameraSolo.combo.Text;
|
|
|
|
//btnIniciarOperacao.Enabled = cmbCameraSolo.SelectedIndex > 0 && cmbCameraCaminho.SelectedIndex > 0;
|
|
|
|
if (CameraSolo.CameraSelecionada != "Sem vídeo" && CameraSolo.CameraSelecionada != "")
|
|
{
|
|
cmbCameraCaminho.Items.Remove(CameraSolo.CameraSelecionada);
|
|
CamerasSolo.Where(x => x.Nome != CamNome).ToList().ForEach(Camera =>
|
|
{
|
|
Camera.combo.Items.Remove(CameraSolo.CameraSelecionada);
|
|
});
|
|
}
|
|
}
|
|
|
|
private void IniciarCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
CameraSolo.camera.IniciarCamera(
|
|
PythonService.ScriptWeedDetector,
|
|
new string[] {
|
|
CameraSolo.MaxLeituras.ToString(),
|
|
CameraSolo.VideoPorta,
|
|
CameraSolo.VideoUrl,
|
|
CameraSolo.ArquivoLeitura,
|
|
"1",
|
|
CameraSolo.SocketPorta
|
|
},
|
|
CameraSolo.VideoPorta,
|
|
CameraSolo.VideoUrl,
|
|
true,
|
|
CameraSolo.SocketPorta
|
|
);
|
|
|
|
if (CameraSolo.browser == null)
|
|
{
|
|
CameraSolo.browser = new ChromiumWebBrowser(CameraSolo.camera.URLcamera);
|
|
CameraSolo.panel.Controls.Add(CameraSolo.browser);
|
|
CameraSolo.browser.Dock = DockStyle.Fill;
|
|
}
|
|
}
|
|
|
|
private void DesligarCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
try
|
|
{
|
|
CameraSolo.panel.Controls.Remove(CameraSolo.browser);
|
|
CameraSolo.browser = null;
|
|
if (CameraSolo.camera.socket != null)
|
|
{
|
|
CameraSolo.camera.socket.Disconnect();
|
|
}
|
|
if (CameraSolo.camera.pythonProcess != null)
|
|
{
|
|
CameraSolo.camera.pythonProcess.Kill();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
private void cmbCameraCaminho_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (cameraCaminho.CameraSelecionada != "Sem vídeo" && cameraCaminho.CameraSelecionada != "")
|
|
{
|
|
//cmbCameraSoloE.Items.Add(cameraCaminhoSelecionada);
|
|
CamerasSolo.ForEach(Camera =>
|
|
{
|
|
Camera.combo.Items.Add(cameraCaminho.CameraSelecionada);
|
|
});
|
|
}
|
|
|
|
cameraCaminho.camera.selectedCamera = cmbCameraCaminho.SelectedIndex;
|
|
if (cameraCaminho.camera.selectedCamera > 0)
|
|
{
|
|
DesligarCameraCaminho();
|
|
IniciarCameraCaminho();
|
|
}
|
|
else
|
|
{
|
|
DesligarCameraCaminho();
|
|
}
|
|
cameraCaminho.CameraSelecionada = cmbCameraCaminho.Text;
|
|
|
|
//btnIniciarOperacao.Enabled = cmbCameraSolo.SelectedIndex > 0 && cmbCameraCaminho.SelectedIndex > 0;
|
|
|
|
if (cameraCaminho.CameraSelecionada != "Sem vídeo" && cameraCaminho.CameraSelecionada != "")
|
|
{
|
|
cmbCameraSoloE.Items.Remove(cameraCaminho.CameraSelecionada);
|
|
CamerasSolo.ForEach(Camera =>
|
|
{
|
|
Camera.combo.Items.Remove(cameraCaminho.CameraSelecionada);
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
private void IniciarCameraCaminho()
|
|
{
|
|
cameraCaminho.ArquivoLeitura = cameraCaminho.ArquivoLeitura;
|
|
cameraCaminho.camera.IniciarCamera(
|
|
PythonService.ScriptStreetDetector,
|
|
new string[] {
|
|
cameraCaminho.MaxLeituras.ToString(),
|
|
cameraCaminho.VideoPorta,
|
|
cameraCaminho.VideoUrl,
|
|
cameraCaminho.ArquivoLeitura,
|
|
"1",
|
|
cameraCaminho.SocketPorta
|
|
},
|
|
cameraCaminho.VideoPorta,
|
|
cameraCaminho.VideoUrl,
|
|
false,
|
|
cameraCaminho.SocketPorta
|
|
);
|
|
|
|
if (cameraCaminho.browser == null)
|
|
{
|
|
cameraCaminho.browser = new ChromiumWebBrowser(cameraCaminho.camera.URLcamera);
|
|
cameraCaminho.panel.Controls.Add(cameraCaminho.browser);
|
|
cameraCaminho.browser.Dock = DockStyle.Fill;
|
|
}
|
|
}
|
|
|
|
private void DesligarCameraCaminho()
|
|
{
|
|
try
|
|
{
|
|
cameraCaminho.panel.Controls.Remove(cameraCaminho.browser);
|
|
cameraCaminho.browser = null;
|
|
if (cameraCaminho.camera.socket != null)
|
|
{
|
|
cameraCaminho.camera.socket.Disconnect();
|
|
}
|
|
if (cameraCaminho.camera.pythonProcess != null)
|
|
{
|
|
cameraCaminho.camera.pythonProcess.Kill();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex.Message);
|
|
}
|
|
}
|
|
|
|
#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
|
|
{
|
|
Variaveis.OperacaoEmAndamento.IniciarOperacao(null, false);
|
|
}
|
|
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)
|
|
{
|
|
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.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)
|
|
{
|
|
Panel pnlContornos = (Panel)sender;
|
|
if (cameraCaminho.Leituras == null || cameraCaminho.Leituras.Count == 0) 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 Leitura in cameraCaminho.Leituras.OrderByDescending(x => x.timestamp))
|
|
{
|
|
foreach (var cameraClass in 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)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
// Plotar apenas a ultima leitura do json
|
|
break;
|
|
}
|
|
|
|
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.ReferencialRuaGPS.AnguloCarro - Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.AnguloRua), 90);
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
private void pnlOrientacao_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
//DesenharInclinacao((Panel)sender, e, (float)GPSService.UltimaLeitura.Orientacao);
|
|
DesenharInclinacao((Panel)sender, e, (float)Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.AnguloCarro, -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(StatusOperacao), Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.StatusAtual);
|
|
lblDirecao.Text = "Direção: " + Enum.GetName(typeof(DirecaoCarroRua), Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.Direcao);
|
|
Console.WriteLine(Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.IdxPontoAproximadoRua);
|
|
//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.ReferencialRuaGPS.StatusAtual == StatusOperacao.Manobrando)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.ReferencialRuaGPS.ManobraConcluida = true;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|