Katakanlah Anda memiliki ini:

P1 = (x=2, y=50)
P2 = (x=9, y=40)
P3 = (x=5, y=20)

Asumsikan itu P1adalah titik pusat sebuah lingkaran. Itu selalu sama. Saya ingin sudut yang dibuat oleh P2dan P3, atau dengan kata lain sudut yang ada di sebelahnya P1. Sudut dalam tepatnya. Itu akan selalu menjadi sudut lancip, jadi kurang dari -90 derajat.

Saya berpikir: Ya ampun, itu matematika geometri sederhana. Tetapi saya telah mencari formula selama sekitar 6 jam sekarang, dan hanya menemukan orang-orang berbicara tentang hal-hal rumit NASA seperti arccos dan hal-hal produk skalar vektor. Kepalaku terasa seperti ada di lemari es.

Beberapa ahli matematika di sini yang menganggap ini masalah sederhana? Saya tidak berpikir bahasa pemrograman penting di sini, tetapi bagi mereka yang menganggapnya penting: java dan objektif-c. Saya membutuhkannya untuk keduanya, tetapi belum memberi tag untuk ini.

Jika yang Anda maksud adalah sudut di mana P1 adalah puncaknya maka gunakan Hukum Cosinus harus bekerja:

arccos((P ₁₂ ² + P ₁₃ ² - P ₂₃ ² ) / (2 * P ₁₂ * P ₁₃ ))

dimana P ₁₂ adalah panjang segmen dari P1 ke P2, dihitung dengan

akar persegi ((P1 _x - P2 _x ) ² + (P1 _y - P2 _y ) ² )

Ini menjadi sangat sederhana jika Anda menganggapnya sebagai dua vektor, satu dari titik P1 ke P2 dan satu dari P1 ke P3

jadi:
a = (p1.x - p2.x, p1.y - p2.y)
b = (p1.x - p3.x, p1.y - p3.y)

Anda kemudian dapat membalik rumus perkalian titik:

untuk mendapatkan sudutnya:

Ingat itu berarti: a1 * b1 + a2 * b2 (hanya 2 dimensi di sini ...)

Cara terbaik untuk menangani komputasi sudut adalah dengan menggunakan atan2(y, x)titik tertentu yang x, ymengembalikan sudut dari titik tersebut dan X+sumbu sehubungan dengan asal.

Mengingat bahwa perhitungannya adalah

double result = atan2(P3.y - P1.y, P3.x - P1.x) -
                atan2(P2.y - P1.y, P2.x - P1.x);

yaitu Anda pada dasarnya menerjemahkan dua poin dengan -P1(dengan kata lain Anda menerjemahkan semuanya sehingga P1berakhir di asal) dan kemudian Anda mempertimbangkan perbedaan sudut absolut dari P3dan dariP2 .

Keuntungan dari atan2adalah bahwa lingkaran penuh terwakili (Anda bisa mendapatkan angka antara -π dan π) di mana sebagai gantinya acosAnda perlu menangani beberapa kasus tergantung pada tanda untuk menghitung hasil yang benar.

Satu-satunya titik tunggal untuk atan2adalah (0, 0)... yang berarti bahwa keduanya P2dan P3harus berbeda dari P1karena dalam kasus itu tidak masuk akal untuk berbicara tentang sudut.

Izinkan saya memberi contoh dalam JavaScript, saya telah banyak berjuang dengan itu:

/**
 * Calculates the angle (in radians) between two vectors pointing outward from one center
 *
 * @param p0 first point
 * @param p1 second point
 * @param c center point
 */
function find_angle(p0,p1,c) {
    var p0c = Math.sqrt(Math.pow(c.x-p0.x,2)+
                        Math.pow(c.y-p0.y,2)); // p0->c (b)   
    var p1c = Math.sqrt(Math.pow(c.x-p1.x,2)+
                        Math.pow(c.y-p1.y,2)); // p1->c (a)
    var p0p1 = Math.sqrt(Math.pow(p1.x-p0.x,2)+
                         Math.pow(p1.y-p0.y,2)); // p0->p1 (c)
    return Math.acos((p1c*p1c+p0c*p0c-p0p1*p0p1)/(2*p1c*p0c));
}

Bonus: Contoh dengan kanvas HTML5

Pada dasarnya yang Anda miliki adalah dua vektor, satu vektor dari P1 ke P2 dan satu lagi dari P1 ke P3. Jadi yang Anda butuhkan hanyalah rumus untuk menghitung sudut antara dua vektor.

Lihat di sini untuk penjelasan yang baik dan rumusnya.

Jika Anda memikirkan P1 sebagai pusat lingkaran, Anda berpikir terlalu rumit. Anda memiliki segitiga sederhana, jadi soal Anda bisa diselesaikan dengan hukum cosinus . Tidak perlu transformasi koordinat kutub atau semacamnya. Misalkan jaraknya adalah P1-P2 = A, P2-P3 = B dan P3-P1 = C:

Sudut = arccos ((B ^ 2-A ^ 2-C ^ 2) / 2AC)

Yang perlu Anda lakukan adalah menghitung panjang jarak A, B, dan C. Itu mudah didapat dari koordinat x dan y titik dan teorema Pythagoras Anda.

Panjang = akar persegi ((X2-X1) ^ 2 + (Y2-Y1) ^ 2)

Saya mengalami masalah serupa baru-baru ini, hanya saja saya perlu membedakan antara sudut positif dan negatif. Jika ini berguna bagi siapa pun, saya merekomendasikan cuplikan kode yang saya ambil dari milis ini tentang mendeteksi rotasi melalui peristiwa sentuh untuk Android:

 @Override
 public boolean onTouchEvent(MotionEvent e) {
    float x = e.getX();
    float y = e.getY();
    switch (e.getAction()) {
    case MotionEvent.ACTION_MOVE:
       //find an approximate angle between them.

       float dx = x-cx;
       float dy = y-cy;
       double a=Math.atan2(dy,dx);

       float dpx= mPreviousX-cx;
       float dpy= mPreviousY-cy;
       double b=Math.atan2(dpy, dpx);

       double diff  = a-b;
       this.bearing -= Math.toDegrees(diff);
       this.invalidate();
    }
    mPreviousX = x;
    mPreviousY = y;
    return true;
 }

Solusi Geometris Sangat Sederhana dengan Penjelasan

_{Beberapa hari yang lalu, seorang jatuh ke masalah yang sama & harus duduk dengan buku matematika. Saya memecahkan masalah dengan menggabungkan dan menyederhanakan beberapa rumus dasar.}

Mari pertimbangkan angka ini-

Kita ingin tahu ϴ , jadi kita perlu cari tahu α dan β dulu. Sekarang, untuk setiap garis lurus-

y = m * x + c

Misalkan- A = (ax, ay) , B = (bx, by) , dan O = (ox, oy) . Jadi untuk garis OA -

oy = m1 * ox + c   ⇒ c = oy - m1 * ox   ...(eqn-1)

ay = m1 * ax + c   ⇒ ay = m1 * ax + oy - m1 * ox   [from eqn-1]
                   ⇒ ay = m1 * ax + oy - m1 * ox
                   ⇒ m1 = (ay - oy) / (ax - ox)
                   ⇒ tan α = (ay - oy) / (ax - ox)   [m = slope = tan ϴ]   ...(eqn-2)

Dengan cara yang sama, untuk baris OB -

tan β = (by - oy) / (bx - ox)   ...(eqn-3)

Sekarang, kami membutuhkannya ϴ = β - α. Dalam trigonometri kami memiliki rumus-

tan (β-α) = (tan β + tan α) / (1 - tan β * tan α)   ...(eqn-4)

Setelah mengganti nilai tan α(dari eqn-2) dan tan b(dari eqn-3) di eqn-4, dan menerapkan penyederhanaan kita dapatkan-

tan (β-α) = ( (ax-ox)*(by-oy)+(ay-oy)*(bx-ox) ) / ( (ax-ox)*(bx-ox)-(ay-oy)*(by-oy) )

Begitu,

ϴ = β-α = tan^(-1) ( ((ax-ox)*(by-oy)+(ay-oy)*(bx-ox)) / ((ax-ox)*(bx-ox)-(ay-oy)*(by-oy)) )

Hanya itu saja!

Sekarang, ambil gambar berikut-

C # atau, metode Java ini menghitung sudut ( ϴ ) -

    private double calculateAngle(double P1X, double P1Y, double P2X, double P2Y,
            double P3X, double P3Y){

        double numerator = P2Y*(P1X-P3X) + P1Y*(P3X-P2X) + P3Y*(P2X-P1X);
        double denominator = (P2X-P1X)*(P1X-P3X) + (P2Y-P1Y)*(P1Y-P3Y);
        double ratio = numerator/denominator;

        double angleRad = Math.Atan(ratio);
        double angleDeg = (angleRad*180)/Math.PI;

        if(angleDeg<0){
            angleDeg = 180+angleDeg;
        }

        return angleDeg;
    }

Di Objective-C Anda bisa melakukannya dengan

float xpoint = (((atan2((newPoint.x - oldPoint.x) , (newPoint.y - oldPoint.y)))*180)/M_PI);

Atau baca lebih lanjut di sini

Anda menyebutkan sudut bertanda (-90). Dalam banyak aplikasi, sudut mungkin memiliki tanda (positif dan negatif, lihat http://en.wikipedia.org/wiki/Angle ). Jika titiknya (katakanlah) P2 (1,0), P1 (0,0), P3 (0,1) maka sudut P3-P1-P2 secara konvensional positif (PI / 2) sedangkan sudut P2-P1- P3 negatif. Menggunakan panjang sisi tidak akan membedakan antara + dan - jadi jika ini penting, Anda perlu menggunakan vektor atau fungsi seperti Math.atan2 (a, b).

Sudut juga dapat melampaui 2 * PI dan sementara ini tidak relevan dengan pertanyaan saat ini, cukup penting bahwa saya menulis kelas Sudut saya sendiri (juga untuk memastikan bahwa derajat dan radian tidak tercampur). Pertanyaan tentang apakah sudut1 lebih kecil dari sudut2 sangat bergantung pada bagaimana sudut didefinisikan. Mungkin juga penting untuk memutuskan apakah baris (-1,0) (0,0) (1,0) direpresentasikan sebagai Math.PI atau -Math.PI

Baru-baru ini, saya juga mengalami masalah yang sama ... Di Delphi Ini sangat mirip dengan Objective-C.

procedure TForm1.FormPaint(Sender: TObject);
var ARect: TRect;
    AWidth, AHeight: Integer;
    ABasePoint: TPoint;
    AAngle: Extended;
begin
  FCenter := Point(Width div 2, Height div 2);
  AWidth := Width div 4;
  AHeight := Height div 4;
  ABasePoint := Point(FCenter.X+AWidth, FCenter.Y);
  ARect := Rect(Point(FCenter.X - AWidth, FCenter.Y - AHeight),
    Point(FCenter.X + AWidth, FCenter.Y + AHeight));
  AAngle := ArcTan2(ClickPoint.Y-Center.Y, ClickPoint.X-Center.X) * 180 / pi;
  AngleLabel.Caption := Format('Angle is %5.2f', [AAngle]);
  Canvas.Ellipse(ARect);
  Canvas.MoveTo(FCenter.X, FCenter.Y);
  Canvas.LineTo(FClickPoint.X, FClickPoint.Y);
  Canvas.MoveTo(FCenter.X, FCenter.Y);
  Canvas.LineTo(ABasePoint.X, ABasePoint.Y);
end;

Berikut adalah metode C # untuk mengembalikan sudut (0-360) berlawanan arah jarum jam dari horizontal untuk sebuah titik pada lingkaran.

    public static double GetAngle(Point centre, Point point1)
    {
        // Thanks to Dave Hill
        // Turn into a vector (from the origin)
        double x = point1.X - centre.X;
        double y = point1.Y - centre.Y;
        // Dot product u dot v = mag u * mag v * cos theta
        // Therefore theta = cos -1 ((u dot v) / (mag u * mag v))
        // Horizontal v = (1, 0)
        // therefore theta = cos -1 (u.x / mag u)
        // nb, there are 2 possible angles and if u.y is positive then angle is in first quadrant, negative then second quadrant
        double magnitude = Math.Sqrt(x * x + y * y);
        double angle = 0;
        if(magnitude > 0)
            angle = Math.Acos(x / magnitude);

        angle = angle * 180 / Math.PI;
        if (y < 0)
            angle = 360 - angle;

        return angle;
    }

Cheers, Paul

ADA jawaban sederhana untuk ini menggunakan matematika sekolah menengah ..

Katakanlah Anda memiliki 3 poin

Untuk mendapatkan sudut dari titik A ke B

angle = atan2(A.x - B.x, B.y - A.y)

Untuk mendapatkan sudut dari titik B ke C.

angle2 = atan2(B.x - C.x, C.y - B.y)

Answer = 180 + angle2 - angle
If (answer < 0){
    return answer + 360
}else{
    return answer
}

Saya baru saja menggunakan kode ini dalam proyek terakhir yang saya buat, ubah B menjadi P1 .. Anda mungkin juga menghapus "180 +" jika Anda mau

nah, jawaban lain sepertinya mencakup semua yang diperlukan, jadi saya ingin menambahkan ini jika Anda menggunakan JMonkeyEngine:

Vector3f.angleBetween(otherVector)

karena itulah yang saya cari di sini :)

      Atan2        output in degrees
       PI/2              +90
         |                | 
         |                |    
   PI ---.--- 0   +180 ---.--- 0       
         |                |
         |                |
       -PI/2             +270

public static double CalculateAngleFromHorizontal(double startX, double startY, double endX, double endY)
{
    var atan = Math.Atan2(endY - startY, endX - startX); // Angle in radians
    var angleDegrees = atan * (180 / Math.PI);  // Angle in degrees (can be +/-)
    if (angleDegrees < 0.0)
    {
        angleDegrees = 360.0 + angleDegrees;
    }
    return angleDegrees;
}

// Angle from point2 to point 3 counter clockwise
public static double CalculateAngle0To360(double centerX, double centerY, double x2, double y2, double x3, double y3)
{
    var angle2 = CalculateAngleFromHorizontal(centerX, centerY, x2, y2);
    var angle3 = CalculateAngleFromHorizontal(centerX, centerY, x3, y3);
    return (360.0 + angle3 - angle2)%360;
}

// Smaller angle from point2 to point 3
public static double CalculateAngle0To180(double centerX, double centerY, double x2, double y2, double x3, double y3)
{
    var angle = CalculateAngle0To360(centerX, centerY, x2, y2, x3, y3);
    if (angle > 180.0)
    {
        angle = 360 - angle;
    }
    return angle;
}

}