Berechne die Kompassrichtung / Richtung zum Standort in Android

@Damian - Die Idee ist sehr gut und ich Stimme mit der Antwort, aber wenn ich Ihren code benutzt, ich hatte falsche Werte, also schrieb ich dies auf meine eigene (jemand erzählt hat, das gleiche in den Kommentaren). Zählen Sie die überschrift mit der Deklination ist gut, denke ich, aber später habe ich benutzt sowas:

heading = (bearing - heading) * -1;

statt Damian code:

heading = myBearing - (myBearing + heading); 

und ändern von -180 bis 180 für 0 bis 360:

      private float normalizeDegree(float value){
          if(value >= 0.0f && value <= 180.0f){
              return value;
          }else{
              return 180 + (180 + value);
          }

dann, wenn Sie wollen, drehen Sie den Pfeil können Sie verwenden, code wie diesen:

      private void rotateArrow(float angle){

            Matrix matrix = new Matrix();
            arrowView.setScaleType(ScaleType.MATRIX);
            matrix.postRotate(angle, 100f, 100f);
            arrowView.setImageMatrix(matrix);
      }

wo arrowView ist ImageView mit Pfeil Bild und 100f Parameter in postRotate ist pivX und pivY).

Ich hoffe, dass ich jemandem helfen.

InformationsquelleAutor der Antwort CookieMonssster

In dieser einen Pfeil auf dem Kompass zeigt die Richtung vom Standort zum Kaaba(Zielort)

können Sie einfach verwenden bearingTo auf diese Weise.Lager, um Ihnen die direkte Winkel vom Standort zum Zielort

  Location userLoc=new Location("service Provider");
    //get longitudeM Latitude and altitude of current location with gps class and  set in userLoc
    userLoc.setLongitude(longitude); 
    userLoc.setLatitude(latitude);
    userLoc.setAltitude(altitude);

   Location destinationLoc = new Location("service Provider");
  destinationLoc.setLatitude(21.422487); //kaaba latitude setting
  destinationLoc.setLongitude(39.826206); //kaaba longitude setting
  float bearTo=userLoc.bearingTo(destinationLoc);

bearingTo geben Sie einen Bereich von -180 bis 180, das wird verwechseln, die Dinge ein wenig. Wir konvertieren zu müssen, diesen Wert in einem Bereich von 0 bis 360 zu Holen Sie sich die richtige Drehung.

Dies ist eine Tabelle von dem, was wir wirklich wollen, im Vergleich zu dem, was bearingTo gibt uns

+-----------+--------------+
| bearingTo | Real bearing |
+-----------+--------------+
| 0         | 0            |
+-----------+--------------+
| 90        | 90           |
+-----------+--------------+
| 180       | 180          |
+-----------+--------------+
| -90       | 270          |
+-----------+--------------+
| -135      | 225          |
+-----------+--------------+
| -180      | 180          |
+-----------+--------------+

also fügen wir diesen code nach bearTo

//If the bearTo is smaller than 0, add 360 to get the rotation clockwise.

  if (bearTo < 0) {
    bearTo = bearTo + 360;
    //bearTo = -100 + 360  = 260;
}

müssen Sie implementiert das SensorEventListener und seine Funktionen(onSensorChanged,onAcurracyChabge) und schreiben Sie den code in onSensorChanged

Vollständige code ist hier für die Richtung der Qibla Kompass

 public class QiblaDirectionCompass extends Service implements SensorEventListener{
 public static ImageView image,arrow;

//record the compass picture angle turned
private float currentDegree = 0f;
private float currentDegreeNeedle = 0f;
Context context;
Location userLoc=new Location("service Provider");
//device sensor manager
private static SensorManager mSensorManager ;
private Sensor sensor;
public static TextView tvHeading;
   public QiblaDirectionCompass(Context context, ImageView compass, ImageView needle,TextView heading, double longi,double lati,double alti ) {

    image = compass;
    arrow = needle;


    //TextView that will tell the user what degree is he heading
    tvHeading = heading;
    userLoc.setLongitude(longi);
    userLoc.setLatitude(lati);
    userLoc.setAltitude(alti);

  mSensorManager =  (SensorManager) context.getSystemService(SENSOR_SERVICE);
    sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
    if(sensor!=null) {
        //for the system's orientation sensor registered listeners
        mSensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_GAME);//SensorManager.SENSOR_DELAY_Fastest
    }else{
        Toast.makeText(context,"Not Supported", Toast.LENGTH_SHORT).show();
    }
    //initialize your android device sensor capabilities
this.context =context;
@Override
public void onCreate() {
    //TODO Auto-generated method stub
    Toast.makeText(context, "Started", Toast.LENGTH_SHORT).show();
    mSensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_GAME); //SensorManager.SENSOR_DELAY_Fastest
    super.onCreate();
}

@Override
public void onDestroy() {
    mSensorManager.unregisterListener(this);
Toast.makeText(context, "Destroy", Toast.LENGTH_SHORT).show();

    super.onDestroy();

}
@Override
public void onSensorChanged(SensorEvent sensorEvent) {


Location destinationLoc = new Location("service Provider");

destinationLoc.setLatitude(21.422487); //kaaba latitude setting
destinationLoc.setLongitude(39.826206); //kaaba longitude setting
float bearTo=userLoc.bearingTo(destinationLoc);

  //bearTo = The angle from true north to the destination location from the point we're your currently standing.(asal image k N se destination taak angle )

  //head = The angle that you've rotated your phone from true north. (jaise image lagi hai wo true north per hai ab phone jitne rotate yani jitna image ka n change hai us ka angle hai ye)



GeomagneticField geoField = new GeomagneticField( Double.valueOf( userLoc.getLatitude() ).floatValue(), Double
        .valueOf( userLoc.getLongitude() ).floatValue(),
        Double.valueOf( userLoc.getAltitude() ).floatValue(),
        System.currentTimeMillis() );
head -= geoField.getDeclination(); //converts magnetic north into true north

if (bearTo < 0) {
    bearTo = bearTo + 360;
    //bearTo = -100 + 360  = 260;
}

//This is where we choose to point it
float direction = bearTo - head;

//If the direction is smaller than 0, add 360 to get the rotation clockwise.
if (direction < 0) {
    direction = direction + 360;
}
 tvHeading.setText("Heading: " + Float.toString(degree) + " degrees" );

RotateAnimation raQibla = new RotateAnimation(currentDegreeNeedle, direction, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
raQibla.setDuration(210);
raQibla.setFillAfter(true);

arrow.startAnimation(raQibla);

currentDegreeNeedle = direction;

//create a rotation animation (reverse turn degree degrees)
RotateAnimation ra = new RotateAnimation(currentDegree, -degree, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);

//how long the animation will take place
ra.setDuration(210);


//set the animation after the end of the reservation status
ra.setFillAfter(true);

//Start the animation
image.startAnimation(ra);

currentDegree = -degree;
}
@Override
public void onAccuracyChanged(Sensor sensor, int i) {

}
@Nullable
@Override
public IBinder onBind(Intent intent) {
    return null;
}

xml-code ist hier

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:background="@drawable/flag_pakistan">
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/heading"
    android:textColor="@color/colorAccent"
    android:layout_centerHorizontal="true"
    android:layout_marginBottom="100dp"
    android:layout_marginTop="20dp"
    android:text="Heading: 0.0" />
<RelativeLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/heading"
android:scaleType="centerInside"
android:layout_centerVertical="true"
android:layout_centerHorizontal="true">

<ImageView
    android:id="@+id/imageCompass"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:scaleType="centerInside"
    android:layout_centerVertical="true"
    android:layout_centerHorizontal="true"
    android:src="@drawable/images_compass"/>

<ImageView
    android:id="@+id/needle"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerVertical="true"
    android:layout_centerHorizontal="true"
    android:scaleType="centerInside"
    android:src="@drawable/arrow2"/>
</RelativeLayout>
</RelativeLayout>

InformationsquelleAutor der Antwort Muhammad Kashif Arif

Hier ist, wie ich es getan haben:

Canvas g = new Canvas( compass );
Paint p = new Paint( Paint.ANTI_ALIAS_FLAG );

float rotation = display.getOrientation() * 90;

g.translate( -box.left, -box.top );
g.rotate( -bearing - rotation, box.exactCenterX(), box.exactCenterY() );
drawCompass( g, p );
drawNeedle( g, p );

InformationsquelleAutor der Antwort Sileria

Terminologie : Der Unterschied zwischen TRUE north und Magnetischen Nordpol, der bekannt ist als "variation", nicht der Deklination. Der Unterschied zwischen dem, was der Kompass liest und die magnetische überschrift ist bekannt als "Abweichung" und variiert mit der überschrift. Eine Kompass-swing-Gerät identifiziert Fehler und ermöglicht Korrekturen angewendet werden, wenn das Gerät über Korrektur eingebaut. Ein magnetischer Kompass eine Abweichung Karte, die beschreibt, Gerät Fehler, die auf jeder Position.

Deklination : Ein Begriff, der in der Astro-navigation : Deklination ist wie die Breite. Es wird berichtet, wie weit ein Stern ist vom Himmelsäquator. Finden Sie die Deklination eines Sterns Folgen eine Stunde Kreis "gerade nach unten", die von dem Stern auf dem Himmelsäquator. Die Winkel, die von dem Stern auf dem Himmelsäquator entlang der Stunden-Kreis ist der Stern der Deklination.

InformationsquelleAutor der Antwort Simon

Dies ist der beste Weg, um zu erkennen, Lager von Location-Objekts auf der Google-Anzeigen:->

 float targetBearing=90;

      Location endingLocation=new Location("ending point"); 

      Location
       startingLocation=new Location("starting point");
       startingLocation.setLatitude(mGoogleMap.getCameraPosition().target.latitude);
       startingLocation.setLongitude(mGoogleMap.getCameraPosition().target.longitude);
       endingLocation.setLatitude(mLatLng.latitude);
       endingLocation.setLongitude(mLatLng.longitude);
      targetBearing =
       startingLocation.bearingTo(endingLocation);

InformationsquelleAutor der Antwort Ramkailash

Die Formel geben, die das Lager über die Koordinaten des start -, Endpunkt und sehen

Den folgenden code, geben Sie die Peilung (Winkel zwischen 0-360)

private double bearing(Location startPoint, Location endPoint) {
    double longitude1 = startPoint.getLongitude();
    double latitude1 = Math.toRadians(startPoint.getLatitude());

    double longitude2 = endPoint.getLongitude();        
    double latitude2 = Math.toRadians(endPoint.getLatitude());

    double longDiff = Math.toRadians(longitude2 - longitude1);

    double y = Math.sin(longDiff) * Math.cos(latitude2);
    double x = Math.cos(latitude1) * Math.sin(latitude2) - Math.sin(latitude1) * Math.cos(latitude2) * Math.cos(longDiff);

    return Math.toDegrees(Math.atan2(y, x));

}

Diese funktioniert für mich, hoffe, es wird anderen auch

InformationsquelleAutor der Antwort K K