Autore Topic: calcolare angolo rispetto al nord  (Letto 1830 volte)

Offline branco

  • Nuovo arrivato
  • *
  • Post: 19
  • Respect: 0
    • Mostra profilo
calcolare angolo rispetto al nord
« il: 13 Ottobre 2012, 17:06:33 CEST »
0
salve a tutti,
ho una app che mi deve dire la mia posizione gps e i gradi rispetto al nord (da dove è orientato il telefono ovviamente)
come devo procedere anche perchè non ho ancora capito la differenza magnetic north  true north?
premetto che ho creato un geomagneticfield e la mia posizione corrente
Codice (Java): [Seleziona]
public Location mCurrentLocation;
Codice (Java): [Seleziona]
public void onLocationChanged(Location location)
        {
            mCurrentLocation = new Location(location);
         }
Codice (Java): [Seleziona]
 Location location = mCurrentLocation;

         if (location != null) {
                geoField = new GeomagneticField( Double
                        .valueOf(location.getLatitude() ).floatValue(), Double
                        .valueOf(location.getLongitude() ).floatValue(),
                        Double.valueOf( location.getAltitude() ).floatValue(),
                        System.currentTimeMillis() );
         }

grazie!

Offline NanoAndroide

  • Utente junior
  • **
  • Post: 63
  • Respect: +3
    • Google+
    • Mostra profilo
    • MeToo
  • Dispositivo Android:
    GT-S5570
  • Play Store ID:
    MeToo
  • Sistema operativo:
    Windows 7
Re:calcolare angolo rispetto al nord
« Risposta #1 il: 04 Aprile 2013, 21:32:43 CEST »
0
Dunque... se ricordo bene, devi ottenere l'orientamento del dispositivo con la funzione location.bearingTo(), che ti da i gradi dal nord magnetico, e la declinazione magnetica con location.getDeclination(), che ti da la differenza tra nord magnetico e nord geografico. Il nord geografico dovrebbe essere dato dalla somma di questi due valori.

Offline tonnuns

  • Utente junior
  • **
  • Post: 81
  • Respect: +1
    • Mostra profilo
  • Sistema operativo:
    Windows
Re:calcolare angolo rispetto al nord
« Risposta #2 il: 04 Maggio 2013, 11:50:54 CEST »
0
Devi fare così:

Codice (Java): [Seleziona]
float baseAzimuth = azimuth;
                                                                       
                                                                        GeomagneticField geoField = new GeomagneticField( Double
                                                                            .valueOf( locHere.getLatitude() ).floatValue(), Double
                                                                            .valueOf( locHere.getLongitude() ).floatValue(),
                                                                            Double.valueOf( locHere.getAltitude() ).floatValue(),
                                                                            System.currentTimeMillis() );
                                                                       
                                                                        azimuth -= geoField.getDeclination(); // converts magnetic north into true north
                                                                       
                                                                        // Store the bearingTo in the bearTo variable
                                                                        float bearTo = locHere.bearingTo( locNext );
                                                                       
                                                                        // If the bearTo is smaller than 0, add 360 to get the rotation clockwise.
                                                                        if (bearTo < 0) {
                                                                            bearTo = bearTo + 360;
                                                                        }
                                                                       
                                                                        //This is where we choose to point it
                                                                        direction = bearTo - azimuth;
                                                                                                                                       
                                                                        // If the direction is smaller than 0, add 360 to get the rotation clockwise.
                                                                        if (direction < 0) {
                                                                            direction = direction + 360;
                                                                        }

L'azimuth l'ottieni dai sensori di posizionamento con questo codice messo nel metodo onSensorChanged(SensorEvent event):

Codice (Java): [Seleziona]
UIDeviceOrientation currentOrientation = this.getCurrentDeviceOrientation();
                SensorManager.getRotationMatrixFromVector(mRotationMatrix , event.values);
           
            SensorManager.getOrientation(mRotationMatrix, orientation);
           
            azimuth = (float) Math.toDegrees(orientation[0]);

Io ho usato un rotationvector ma puoi usare anche l'accelerometro e magnetic field

Spero di esserti stato utile

Offline cri260791

  • Nuovo arrivato
  • *
  • Post: 1
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy S3 Mini
  • Sistema operativo:
    Windows 8
Re:calcolare angolo rispetto al nord
« Risposta #3 il: 08 Agosto 2013, 12:21:12 CEST »
0
Ciao a tutti ero veramente nel panico, ma ho trovato questo utile topic. Sto sviluppando per la tesi per l'università una applicazione per android che riconosce la posizione del telefono e la direzione nella quale sta guardando, per vedere quali altri telefoni ci sono nel suo punto di vista.
Ho seguito la guida di android developers e una parte del codice qui sopra, del quale però non ho capito a cosa serve la locNext, io vorrei potere definire la direzione senza avere bisogno di un secondo punto.

Il codice che ho scritto qui sotto funziona, ma vorrei sapere se esiste un modo per renderlo più accurato (in particolare, la direzione rilevata è precisa solo quando il telefono è in posizione orizzontale):

Codice (Java): [Seleziona]
this.azimuth = 0;
this.sensorManager = (SensorManager) this.helper.getActivity().getSystemService(Context.SENSOR_SERVICE);
this.sensor = this.sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
this.sensorManager.registerListener(this, this.sensor, 10000);                 
this.locationManager = (LocationManager) this.helper.getActivity().getSystemService(Context.LOCATION_SERVICE);
               
this.locationListener = new LocationListener() {
                       
        @Override
        public void onLocationChanged(Location location) {
         AndroidRealAgent.this.location = location;
                               
        }

                        @Override
                        public void onProviderDisabled(String provider) {
                                // TODO Auto-generated method stub
                               
                        }

                        @Override
                        public void onProviderEnabled(String provider) {
                                // TODO Auto-generated method stub
                               
                        }

                        @Override
                        public void onStatusChanged(String provider, int status,
                                        Bundle extras) {
                                // TODO Auto-generated method stub
                               
                        }
                };
               
                this.helper.getActivity().runOnUiThread(new Runnable() {
                       
                        @Override
                        public void run() {
                                AndroidRealAgent.this.locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, AndroidRealAgent.this.locationListener);
                               
                        }
                });

@Override
        public double getCurrentDirection() {
                double azimuth;
               
                if (this.location != null){
               
                        GeomagneticField geoField = new GeomagneticField(
                                        Double.valueOf( this.location.getLatitude()).floatValue(),
                                        Double.valueOf( this.location.getLongitude()).floatValue(),
                        Double.valueOf( this.location.getAltitude()).floatValue(),
                        System.currentTimeMillis()
                );
                       
                        azimuth = EarthGeometry.getStandardRangeDirection(this.azimuth - geoField.getDeclination());
                       
                        return azimuth;
                }
               
                return this.direction;
        }

        @Override
        public void onAccuracyChanged(Sensor sensor, int accuracy) {
                // TODO Auto-generated method stub
               
        }

        @Override
        public void onSensorChanged(SensorEvent event) {
                float[] rotationMatrix = new float[16];
                float[] values = new float[3];
               
                if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR){
                       
                        SensorManager.getRotationMatrixFromVector( rotationMatrix , event.values);
                        SensorManager.getOrientation(rotationMatrix, values);
                       
                        this.azimuth = Math.toDegrees(values[0]);
                }
        }

Note:
-la classe si chiama RealAndroidAgent
-EarthGeometry.getStandardRangeDirection restituisce l'angolo passato in modo tale che sia compreso fra 0 e 360 gradi
-questa classe non è una activity, ma conosce l'activity che l'ha creata tramite helper.getActivity()
« Ultima modifica: 08 Agosto 2013, 12:30:44 CEST da cri260791 »

Offline Nicola_D

  • Utente storico
  • *****
  • Post: 2479
  • SBAGLIATO!
  • Respect: +323
    • Github
    • Google+
    • nicoladorigatti
    • Mostra profilo
  • Dispositivo Android:
    Nexus 6p, Nexus 4, Nexus S, Nexus 7(2012)
  • Sistema operativo:
    Windows 7
Re:calcolare angolo rispetto al nord
« Risposta #4 il: 08 Agosto 2013, 14:02:39 CEST »
0
questo ti può aiutare: Location | Android Developers()
?
IMPORTANTE:NON RISPONDO A PROBLEMI VIA MESSAGGIO PRIVATO
LOGCAT: Non sai cos'è? -> Android Debug Bridge | Android Developers
               Dov'è in Eclipse? -> Window -> Open Prospective -> DDMS e guarda in basso!
[Obbligatorio] Logcat, questo sconosciuto! (Gruppo AndDev.it LOGTFO) - Android Developers Italia