दो बिंदुओं द्वारा परिभाषित लाइन के बीच कोण की गणना

Question

मैं वर्तमान में एंड्रॉइड के लिए एक साधारण 2 डी गेम विकसित कर रहा हूं। मेरे पास एक स्थिर ऑब्जेक्ट है जो स्क्रीन के केंद्र में स्थित है और मैं उस ऑब्जेक्ट को घुमाने और स्क्रीन पर उस क्षेत्र को इंगित करने की कोशिश कर रहा हूं जिसे उपयोगकर्ता स्पर्श करता है। मेरे पास निरंतर निर्देशांक हैं जो स्क्रीन के केंद्र का प्रतिनिधित्व करते हैं और मैं उस बिंदु के निर्देशांक प्राप्त कर सकता हूं जिस पर उपयोगकर्ता टैप करता है। मैं सूत्र इस मंच में उल्लिखित उपयोग कर रहा हूँ:

double angle = atan2(y2 - y1, x2 - x1) * 180/PI;". 

: How to get angle between two points?

• यह इस प्रकार के रूप में "कहते हैं आप लाइन इन दो बिंदुओं और क्षैतिज अक्ष द्वारा परिभाषित के बीच के कोण चाहते हैं

  मैंने इसे कार्यान्वित किया, लेकिन मुझे लगता है कि मैं स्क्रीन निर्देशांक में काम कर रहा हूं, यह तथ्य गलत है क्योंकि वाई-समन्वय उलट दिया गया है। मुझे यकीन नहीं है कि यह इसके बारे में जाने का सही तरीका है, कोई अन्य विचार या सुझावों की सराहना की जाती है।

Answer 1

मानदंड: x क्षैतिज धुरी है, और बाएं से दाएं स्थानांतरित होने पर बढ़ता है। y ऊर्ध्वाधर धुरी है, और नीचे से ऊपर तक बढ़ता है। (touch_x, touch_y) उपयोगकर्ता द्वारा चुने गए बिंदु है। (center_x, center_y) स्क्रीन के केंद्र में बिंदु है। theta+x अक्ष से काउंटर-घड़ी के विपरीत मापा जाता है। तब:

delta_x = touch_x - center_x 
delta_y = touch_y - center_y 
theta_radians = atan2(delta_y, delta_x) 

संपादित: यदि आप ऊपर से नीचे तक कि y बढ़ जाती है एक टिप्पणी में उल्लेख किया है। कि मामले में,

delta_y = center_y - touch_y 

लेकिन यह अधिक व्यक्त (touch_x, touch_y) ध्रुवीय में (center_x, center_y) के सापेक्ष निर्देशांक के रूप में इस का वर्णन करने के लिए सही होगा। जैसा कि क्रिसफ ने उल्लेख किया है, "दो बिंदुओं के बीच कोण" लेने का विचार अच्छी तरह परिभाषित नहीं है।

Answer 2

अपने आप को इसी तरह की सुविधा के लिए एक की जरूरत थी, इतना बाल खींचने के बाद मैं

/** 
* Fetches angle relative to screen centre point 
* where 3 O'Clock is 0 and 12 O'Clock is 270 degrees 
* 
* @param screenPoint 
* @return angle in degress from 0-360. 
*/ 
public double getAngle(Point screenPoint) { 
    double dx = screenPoint.getX() - mCentreX; 
    // Minus to correct for coord re-mapping 
    double dy = -(screenPoint.getY() - mCentreY); 

    double inRads = Math.atan2(dy, dx); 

    // We need to map to coord system when 0 degree is at 3 O'clock, 270 at 12 O'clock 
    if (inRads < 0) 
     inRads = Math.abs(inRads); 
    else 
     inRads = 2 * Math.PI - inRads; 

    return Math.toDegrees(inRads); 
} 

Answer 3

नीचे समारोह के साथ आया था "मूल में है ऊपर-बाईं ओर स्क्रीन के और y- निर्देशांक बढ़ जाती है के लिए जा रहा नीचे, जबकि एक्स-कोऑर्डिनेट सामान्य की तरह दाएं हो जाता है। मुझे लगता है कि मेरा प्रश्न बन गया है, क्या मुझे उपरोक्त फॉर्मूला को लागू करने से पहले स्क्रीन निर्देशांक को कार्टेशियन निर्देशांक में परिवर्तित करना होगा? "

आप कार्तीय निर्देशांक का उपयोग कर कोण की गणना कर रहे थे, और दोनों अंक वृत्त का चतुर्थ भाग 1 में थे (जहां x> 0 और y> 0), स्थिति स्क्रीन पिक्सेल निर्देशांक के समान (उलटा-Y के अलावा होगा चीज। अगर आप इसे सही दिशा में लाने के लिए वाई को अस्वीकार करते हैं, तो यह चतुर्भुज 4 हो जाता है ...)। कार्टेशियन को स्क्रीन पिक्सेल निर्देशांक कनवर्ट करना वास्तव में कोण को नहीं बदलता है।

Answer 4

यहाँ कुछ जवाब "स्क्रीन" मुद्दा समझाने के लिए जहां top left0,0 और bottom right (सकारात्मक) screen width, screen height है की कोशिश की है। अधिकांश ग्रिड में Y अक्ष X से ऊपर सकारात्मक के रूप में नीचे नहीं है।

निम्न विधि "ग्रिड" मानों के बजाय स्क्रीन मानों के साथ काम करेगी। छोड़कर उत्तर में केवल अंतर Y मान उलटा हुआ है।

/** 
* Work out the angle from the x horizontal winding anti-clockwise 
* in screen space. 
* 
* The value returned from the following should be 315. 
* <pre> 
* x,y ------------- 
*  | 1,1 
*  | \ 
*  |  \ 
*  |  2,2 
* </pre> 
* @param p1 
* @param p2 
* @return - a double from 0 to 360 
*/ 
public static double angleOf(PointF p1, PointF p2) { 
    // NOTE: Remember that most math has the Y axis as positive above the X. 
    // However, for screens we have Y as positive below. For this reason, 
    // the Y values are inverted to get the expected results. 
    final double deltaY = (p1.y - p2.y); 
    final double deltaX = (p2.x - p1.x); 
    final double result = Math.toDegrees(Math.atan2(deltaY, deltaX)); 
    return (result < 0) ? (360d + result) : result; 
}