public Rota_Waypoint ProximoWaypoint(Rota_Waypoint atual)
    {
        if (!atual)
        {
            CarregaWaypoints();
            return(waypoints[0]);
        }

        int aux = waypoints.IndexOf(atual);

        if (aux + 1 >= waypoints.Count)
        {
            if (waypointsEmCiclo)
            {
                return(waypoints[0]);
            }
            else
            {
                return(null);
            }
        }
        else
        {
            return(waypoints[aux + 1]);
        }
    }
示例#2
0
    public void ListarWaypointWebService(Rota_Waypoint rota_Waypoint)
    {
        GUI_Rota_WebService_Dados_WP obj =
            Instantiate(
                interfaceGrafica.dadosWPAlcancado,
                interfaceGrafica.rotaWebService.scrollViewContent.transform);

        obj.waypoint = rota_Waypoint;

        interfaceGrafica.rotaWebService.dadosDosWPWeb.Add(obj);
        int id = interfaceGrafica.rotaWebService.dadosDosWPWeb.IndexOf(obj);

        obj.AjustarTextos(false, id + 1,
                          obj.waypoint.posOrigGPS, obj.waypoint.posOrigXYZ, obj.waypoint.posAjustXYZ,
                          obj.waypoint.dt_horarioParaAlcancar.ToString(formatoDateTime), null, float.NaN);
    }
示例#3
0
    public void WaypointWebServiceAlcancado(Rota_Waypoint waypoint, Biarticulado biarticulado)
    {
        foreach (var item in interfaceGrafica.rotaWebService.dadosDosWPWeb)
        {
            if (item.waypoint == waypoint)
            {
                item.waypoint.dt_horarioAlcancado = dt_simulationCurrentTime;
                TimeSpan ts = item.waypoint.dt_horarioAlcancado - item.waypoint.dt_horarioParaAlcancar;
                float    adiantamentoOuAtraso = (float)ts.TotalSeconds;

                int id = interfaceGrafica.rotaWebService.dadosDosWPWeb.IndexOf(item);
                item.AjustarTextos(true, id + 1,
                                   item.waypoint.posOrigGPS, item.waypoint.posOrigXYZ, item.waypoint.posAjustXYZ,
                                   item.waypoint.dt_horarioParaAlcancar.ToString(formatoDateTime), item.waypoint.dt_horarioAlcancado.ToString(formatoDateTime), adiantamentoOuAtraso);

                biarticulado.tempoAtrasadoOuAdiantado += adiantamentoOuAtraso;
                break;
            }
        }
    }
 //Usada logo quando o Biarticulado é inicializado, ou quando ele passa por um Waypoint qualquer.
 public void AtualizarRota(Rota_Waypoint wp)
 {
     if (!wp)
     {
         wp_proximo  = rota.ProximoWaypoint(null);
         wp_seguinte = rota.ProximoWaypoint(wp_proximo);
     }
     else if (wp == wp_proximo)
     {
         if (wp.tipoWaypoint == CVP.ModuloOnibus.TipoWaypont.PARADA && !paradoEmPonto)
         {
             veiculoSendoParado = true;
             parando_Ponto      = true;
         }
         else
         {
             wp_proximo  = rota.ProximoWaypoint(wp_proximo);
             wp_seguinte = rota.ProximoWaypoint(wp_proximo);
         }
     }
 }
示例#5
0
    public static bool AjustarPosicoesParaRotaPadrao(Rota rota, Vector3 posOriginal, float toleranciaDistanciaParaRota, out Vector3 posAjustada)
    {
        /*
         * Basicamente:
         * 1.      Para cada Waypoint da Rota:
         * 1.1.    Gera uma reta (em unitês: Ray) a partir de cada 2 Waypoints consecutivos da rota.
         * 1.2.    Calcula a distância do ponto a ser ajustado para esta reta.
         * 1.3.    Se a distância for igual ou menor que distanciaMaxima
         * 1.3.1.  Armazena a reta gerada.
         * 1.3.2.  Redefine distanciaMaxima como sendo essa distância.
         * //      TODO:   Ainda não há verificação se o ponto está realisticamente próximo dos Waypoints ou do trajeto entre os dois Waypoints
         * 2.      Se foi definida uma reta válida:
         * 2.1.    Calcula a posição ajustada para a reta encontrada.
         * 2.1.    Retorna TRUE
         * 3.      Senão
         * 3.1.    Retorna FALSE
         */

        Rota_Waypoint wpA, wpB;
        float         dist_Found = float.NaN;
        Rota_Waypoint wpA_Found = null, wpB_Found = null;

        for (int i = 1; i <= rota.waypoints.Count; i++)
        {
            wpA = rota.waypoints[i - 1];
            if (i >= rota.waypoints.Count)
            {
                if (rota.waypointsEmCiclo)
                {
                    wpB = rota.waypoints[0];
                }
                else
                {
                    break;
                }
            }
            else
            {
                wpB = rota.waypoints[i];
            }

            //Para evitar de ficar comparando com pares de waypoints muito distantes da posição original informada.
            float dist_orig_To_wpA = Vector3.Distance(posOriginal, wpA.transform.position);
            float dist_orig_To_wpB = Vector3.Distance(posOriginal, wpB.transform.position);
            if (dist_orig_To_wpA <= toleranciaDistanciaParaRota && dist_orig_To_wpB <= toleranciaDistanciaParaRota)
            {
                float aux = DistanciaEntrePontoESegmentoDeReta(posOriginal, wpA.transform.position, wpB.transform.position);

                if (float.IsNaN(dist_Found) || aux < dist_Found)
                {
                    dist_Found = aux;
                    wpA_Found  = wpA;
                    wpB_Found  = wpB;
                }
            }
        }

        if (wpA_Found && wpB_Found)
        {
            float x = Mathf.Clamp(
                posOriginal.x,
                Mathf.Min(wpA_Found.transform.position.x, wpB_Found.transform.position.x),
                Mathf.Max(wpA_Found.transform.position.x, wpB_Found.transform.position.x));
            float y = Mathf.Clamp(
                posOriginal.y,
                Mathf.Min(wpA_Found.transform.position.y, wpB_Found.transform.position.y),
                Mathf.Max(wpA_Found.transform.position.y, wpB_Found.transform.position.y));
            float z = Mathf.Clamp(
                posOriginal.z,
                Mathf.Min(wpA_Found.transform.position.z, wpB_Found.transform.position.z),
                Mathf.Max(wpA_Found.transform.position.z, wpB_Found.transform.position.z));
            posAjustada = new Vector3(x, y, z);
            return(true);
        }
        else
        {
            posAjustada = Vector3.zero;
            return(false);
        }
    }
    private void GerarWaypoints()
    {
        List <PosicaoGPS> newPosicoesGPS = new List <PosicaoGPS>();
        int count = 0;

        string idBus    = "BD126";
        string dataHora = "";

        //dataHora = "2016-06-29%2020:07:13";
        //dataHora = gerenciadorDeCena.dt_simulationCurrentTime.ToShortDateString() + "%20" + gerenciadorDeCena.dt_simulationCurrentTime.ToShortTimeString();
        dataHora += gerenciadorDeCena.dt_simulationCurrentTime.Year;
        dataHora += "-";
        dataHora += gerenciadorDeCena.dt_simulationCurrentTime.Month;
        dataHora += "-";
        dataHora += gerenciadorDeCena.dt_simulationCurrentTime.Day;
        dataHora += "%20";
        dataHora += gerenciadorDeCena.dt_simulationCurrentTime.Hour;
        dataHora += ":";
        dataHora += gerenciadorDeCena.dt_simulationCurrentTime.Minute;
        dataHora += ":";
        dataHora += gerenciadorDeCena.dt_simulationCurrentTime.Second;
        dataHora += ".";
        dataHora += gerenciadorDeCena.dt_simulationCurrentTime.Millisecond;

        List <PosicaoGPS> retornoWebservice =
            webAPICon.
            CallWebService(idBus, dataHora);

        if (retornoWebservice == null || retornoWebservice.Count <= 0)
        {
            Debug.LogWarning("O WebService não pode ser contactado, ou o mesmo não retornou posição alguma.");
            return;
        }

        foreach (var item in retornoWebservice)
        {
            //DateTime dt = DateTime.ParseExact(item.DTHR, gerenciadorDeCena.formatoDateTime, System.Globalization.CultureInfo.InvariantCulture);
            //if (DateTime.Compare(dt, gerenciadorDeCena.dt_simulationCurrentTime) >= 0)
            if (DateTime.Compare(item.DTHR, gerenciadorDeCena.dt_simulationCurrentTime) >= 0)
            {
                newPosicoesGPS.Add(item);
                count++;
            }

            if (count >= itensParaRetornar)
            {
                posicoesGPS.AddRange(newPosicoesGPS);
                break;
            }
        }

        Vector3    posOrigGPS  = new Vector3();
        Vector3    posOrigXYZ  = new Vector3();
        Vector3    posAjustXYZ = new Vector3();
        Quaternion rot         = new Quaternion();

        foreach (var item in newPosicoesGPS)
        {
            float lat = float.Parse(item.LAT.Replace(',', '.'));
            float lon = float.Parse(item.LON.Replace(',', '.'));
            posOrigGPS = new Vector3(lat, lon, 0);
            posOrigXYZ = CVP_Calculos.GPS_to_XYZ(posOrigGPS.x, posOrigGPS.y, posOrigGPS.z);
            if (CVP_Calculos.AjustarPosicoesParaRotaPadrao(rota, posOrigXYZ, toleranciaDistanciaParaRota, out posAjustXYZ))
            {
                //posAjustXYZ
                //Rota_Waypoint wp = Instantiate(prefab_Waypoint, posOrigXYZ, rot, this.transform);
                Rota_Waypoint wp = Instantiate(prefab_Waypoint, posAjustXYZ, rot, this.transform);

                wp.go_posOrig.gameObject.SetActive(true);
                wp.go_posOrig.transform.position = posOrigXYZ;
                wp.go_posAjust.gameObject.SetActive(true);
                wp.go_posAjust.transform.position = posAjustXYZ;

                wp.rota         = rota;
                wp.tipoWaypoint = CVP.ModuloOnibus.TipoWaypont.WEBSERVICE;

                wp.dt_spawn = gerenciadorDeCena.dt_simulationCurrentTime;
                wp.dt_horarioParaAlcancar = item.DTHR;
                wp.PreencherParametrosDataHora();

                wp.posOrigGPS  = posOrigGPS;
                wp.posOrigXYZ  = posOrigXYZ;
                wp.posAjustXYZ = posAjustXYZ;

                waypoints.Add(wp);
                gerenciadorDeCena.ListarWaypointWebService(wp);
            }
            else
            {
                Debug.Log("Uma posição GPS foi descartada, pos durante o ajuste esta ficou longe demais da Rota.");
            }
        }
    }