दिए गए केंद्र बिंदु, त्रिज्या और डिग्री के साथ एक वृत्त पर बिंदु का पता लगाएं

Question

मुझे इस तरह कोई गणित करते हुए 10 साल हो गए हैं ... मैं 2 डी में एक गेम की प्रोग्रामिंग कर रहा हूं और एक खिलाड़ी को घुमा रहा हूं। जैसा कि मैंने खिलाड़ी को चारों ओर घुमाया, मैं -360 से 360 के बीच एक सकारात्मक या नकारात्मक कोण (डिग्री) को देखते हुए खिलाड़ी की स्थिति से 200 सर्कल की दूरी पर बिंदु की गणना करने की कोशिश कर रहा हूं। स्क्रीन 0x केंद्र बिंदु होने के साथ 1280x720 है स्क्रीन के। खिलाड़ी इस पूरे कार्टेशियन समन्वय प्रणाली के चारों ओर घूमता है। मैं जिस बिंदु को खोजने की कोशिश कर रहा हूं वह ऑफ स्क्रीन हो सकता है।

मैंने लेख पर सूत्रों की कोशिश की त्रिज्या और कोण के साथ बिंदु खोजें, लेकिन मुझे विश्वास नहीं होता कि मैं समझ रहा हूं कि "कोण" क्या है क्योंकि मुझे अजीब परिणाम मिल रहे हैं जब मैं कोण से -360 से 360 के बीच कोस (कोण) या पाप में गुजरता हूं (कोण)।

इसलिए उदाहरण के लिए मेरे पास ...

• कार्टेशियन प्लेन पर 1280x720
• केंद्र बिंदु (खिलाड़ी की स्थिति):
  • x = न्यूनतम -40 से अधिकतम 640 के बीच की संख्या
  • चलो y = न्यूनतम -360 से अधिकतम 360 के बीच की संख्या
• खिलाड़ी के चारों ओर सर्किल का त्रिज्या: आर को हमेशा = 200 पर रखें
• कोण: a = -360 से 360 के बीच दी गई संख्या (नकारात्मक को नीचे की ओर इंगित करने की अनुमति दें या सकारात्मक-तो ऊपर की ओर इंगित करें -10 और 350 समान उत्तर देगा)

X को वृत्त पर वापस लाने का सूत्र क्या है?

सर्कल पर Y को वापस करने का फॉर्मूला क्या है?

Comments

यह अच्छा प्रश्न है!!! +1

— फ्रॉस्टीफायर

प्रश्न: क्या अधिकांश खेलों में 0,0 से ऊपर के भाग में तारबंदी नहीं है? और y अक्ष नीचे जाता है, ऊपर नहीं?

— फारस

Answer 1

आपके लिंक से सरल समीकरण सर्कल के केंद्र के सापेक्ष सर्कल पर बिंदु के एक्स और वाई निर्देशांक देते हैं ।

X = r * cosine(angle)  
Y = r * sine(angle)

यह आपको बताता है कि सर्कल के केंद्र से बिंदु कितनी दूर है। चूंकि आपके पास केंद्र (Cx, Cy) के निर्देशांक हैं, बस गणना की गई ऑफसेट जोड़ें।

सर्कल पर बिंदु के निर्देशांक हैं:

X = Cx + (r * cosine(angle))  
Y = Cy + (r * sine(angle))

Comments

मेरा भ्रम पहले ANGLE और DEGREE के बीच अंतर था। मुझे लगा कि वे भी वही हैं। तब मुझे लगा कि विमान पर मुझे बिंदु (x, y) मिल रहा है, लेकिन मुझे वास्तव में x और y के पक्षों की लंबाई मिल रही थी। मैंने इसे कागज़ पर निकाल दिया और फिर इसे सूत्रों की जाँच के लिए डिग्री की सीमा को कवर करने के लिए एक्सेल में बंद कर दिया। यह अब मेरे कोड में काम करता है।

— काइल एंडरसन

(और इसके विपरीत ) नहीं X = xcircle + (r * sine(angle))होना चाहिए ? X = xcircle + (r * cosine(angle))Y

— txtechhelp

ध्यान दें कि रेडियन में कोण का मान होना चाहिए!

— रोमन एम।

Answer 2

आपको उस कोड को पोस्ट करना चाहिए जिसका आप उपयोग कर रहे हैं। इससे समस्या की पहचान करने में मदद मिलेगी।

हालाँकि, जब से आपने अपने कोण को -360 से 360 के संदर्भ में मापने का उल्लेख किया है, आप संभवतः अपने गणित पुस्तकालय के लिए गलत इकाइयों का उपयोग कर रहे हैं। त्रिकोणमिति कार्यों के अधिकांश कार्यान्वयन उनके इनपुट के लिए रेडियन का उपयोग करते हैं। और अगर आप इसके बजाय डिग्री का उपयोग करते हैं ... तो आपके उत्तर अजीब तरह से गलत होंगे।

x_oncircle = x_origin + 200 * cos (degrees * pi / 180)
y_oncircle = y_origin + 200 * sin (degrees * pi / 180)

ध्यान दें कि आप उस परिस्थिति में भी भाग सकते हैं जहाँ चतुर्थांश वह नहीं है जिसकी आप अपेक्षा करते हैं। यह ध्यान से तय करके तय किया जा सकता है कि कोण शून्य कहां है, या मैन्युअल रूप से आपके द्वारा अपेक्षित मानों की जांच करने और परिणाम मानों पर अपने स्वयं के संकेतों को लागू करने की जाँच करके।

Comments

यह वास्तव में एक उत्तर के बजाय एक टिप्पणी होनी चाहिए। हालांकि, रेडियन बनाम डिग्री पर अच्छी पकड़ है।

— yoozer8

ज़ोंबी पोस्ट प्रश्न: parens में, वह (deg * (pi / 180))या दूसरा तरीका है ((deg * pi) / 180)? रेड बनाम डिग के बीच अंतर को निर्दिष्ट करने के लिए भी धन्यवाद।

— मैन्स्टो

@monsto लाश अभी भी सूचनाएं भेजती हैं। :)। भीतर के मामले मायने नहीं रखते क्योंकि गुणा और भाग कम्यूटेटिव प्रदर्शन हैं ।wolfram.com/… । मैं अपने कोड में अत्यधिक पारेंस डालने का दोषी हूं। मैं यह स्पष्टता के लिए दिखावा करता हूं, लेकिन स्पष्ट रूप से यह कड़ाई से सच नहीं है, या आप इससे परेशान नहीं होंगे।

— सेठ बैतीन

Answer 3

मैं इस प्रकार के जोड़तोड़ के लिए मैट्रिसेस का उपयोग करने का सुझाव देता हूं। यह सबसे सामान्य दृष्टिकोण है, नीचे उदाहरण देखें:

// The center point of rotation
var centerPoint = new Point(0, 0);
// Factory method creating the matrix                                        
var matrix = new RotateTransform(angleInDegrees, centerPoint.X, centerPoint.Y).Value;
// The point to rotate
var point = new Point(100, 0);
// Applying the transform that results in a rotated point                                      
Point rotated = Point.Multiply(point, matrix); 

• साइड नोट, कन्वेंशन को एंगल काउंटर क्लॉकवाइज़ स्टार्टिंग फॉर्म (पॉज़िटिव) एक्स-एक्सिस को मापने के लिए है

Answer 4

मुझे अजीब परिणाम मिल रहे हैं जब मैं कोण को -360 से 360 के लिए एक कॉस (कोण) या पाप (कोण) में पास करता हूं।

मुझे लगता है कि आपके प्रयास से काम न करने का कारण यह है कि आप डिग्री में कोण पास कर रहे थे। sinऔर cosत्रिकोणमितीय कार्यों रेडियन में व्यक्त कोण की उम्मीद है, तो नंबर से किया जाना चाहिए 0करने के लिए 2*M_PI। के लिए dडिग्री आप पारित M_PI*d/180.0। हेडर M_PIमें एक निरंतर परिभाषित है math.h।

Comments

मुझे लगा कि कोण और डिग्री शायद एक ही चीज़ नहीं थी तो क्या मैं एंगल = M_PI * d / 180.0 कहने में सही हूँ जहाँ d -360 से 360 तक की संख्या हो सकती है या मुझे दूसरे चरण की आवश्यकता है?

— काइल एंडरसन

@Kyle dसे है 0करने के लिए 360या से -180करने के लिए 180(एक पूरा चक्र), से नहीं -360करने के लिए 360(दो पूरा हलकों)।

— सर्गेई कालिनिचेंको

Answer 5

कोड में घड़ी के हाथों की गति को बनाने के लिए मुझे इसकी भी आवश्यकता थी। मैंने कई फॉर्मूले आज़माए लेकिन वे काम नहीं आए, इसलिए यही मेरे साथ आया:

• गति - दक्षिणावर्त
• अंक - प्रत्येक 6 डिग्री (क्योंकि 360 डिग्री 60 minuites द्वारा विभाजित 6 डिग्री है)
• हाथ की लंबाई - 65 पिक्सेल
• केंद्र - x = 75, y = 75

तो सूत्र होगा

x=Cx+(r*cos(d/(180/PI))
y=Cy+(r*sin(d/(180/PI))

जहां x और y एक वृत्त की परिधि के बिंदु हैं, Cx और Cy केंद्र के x, y निर्देशांक हैं, r त्रिज्या है, और d डिग्री की मात्रा है।

Answer 6

यहाँ c # कार्यान्वयन है। विधि परिपत्र बिंदुओं को लौटाएगी जो पैरामीटर के रूप में radius, centerऔर ले जाती है angle interval। कोण को रेडियन के रूप में पारित किया गया है।

public static List<PointF> getCircularPoints(double radius, PointF center, double angleInterval)
        {
            List<PointF> points = new List<PointF>();

            for (double interval = angleInterval; interval < 2 * Math.PI; interval += angleInterval)
            {
                double X = center.X + (radius * Math.Cos(interval));
                double Y = center.Y + (radius * Math.Sin(interval));

                points.Add(new PointF((float)X, (float)Y));
            }

            return points;
        }

और कॉलिंग उदाहरण:

List<PointF> LEPoints = getCircularPoints(10.0f, new PointF(100.0f, 100.0f), Math.PI / 6.0f);

Comments

बीवेयर यह है कि यह राउंडिंग त्रुटियों के कारण अपेक्षा से 1 कम आइटम वापस कर सकता है! इसलिए मैंने कुछ मार्चिंग को जोड़ा ताकि मुझे अंत में सही मात्रा में आइटम मिलें (मेरा उदाहरण डबल के बजाय तैरता है); के लिए (फ्लोट इंटरवल = एंगलइंटरवल; इंटरवल <2 * मैथ.आई + 0.0000099 एफ; अंतराल + = एंगल इन्टरवल)

— sommmen

Answer 7

मैं साझा करना चाहता था कि ऊपर दिए गए आपके योगदान से मुझे Arduino LCD कम्पास बनाने में कैसे मदद मिली। मुझे आशा है कि यह सही शिष्टाचार है ... मैं सिर्फ स्टैकओवरफ्लो में शामिल हुआ, ताकि मैं आप लोगों को धन्यवाद दे सकूं।

ऊपर ज्यामिति दिग्गजों के कंधों पर खड़े होने के दौरान मैं इस नमूने कम्पास का उत्पादन करने में सक्षम था: कई बीयरिंगों के साथ Arduino TFT कम्पास

फ़ंक्शन के लिए कोड जिसे मैंने बार-बार कॉल किया (अलग-अलग बीयरिंगों के लिए आप छोटे पीले पाठ में देखते हैं) Arduino ("C" जैसे थोड़े में लिखा गया है) ... और बहुत अनुवाद योग्य है:

void PaintCompassNeedle( int pBearingInDegrees, int pRadius, TSPoint pCentrePt ) {
    // ******************************************************************************
    // * Formula for finding pointX on the circle based on degrees around the circle:
    // * x_oncircle = x_origin + radius * cos (degrees * pi / 180)  
    // * y_oncircle = y_origin - radius * sin (degrees * pi / 180) //minus explained
    // * Thanks to folks at stackoverflow...standing on the shoulders of giants. :) 

    float bearingInRads = (pBearingInDegrees) * PI / 180; 
    // Degrees vs Rads...The math folks use Rads in their formulas

    // *******************************************************************
    // * bearingPt is the point on the circle that we are trying to find
    TSPoint bearingPt;
    // Find the X on the circle starting with orgin (centre)
    bearingPt.x = pCentrePt.x + pRadius * sin(bearingInRads); 
    // Notice the "minus" R * cos()...because TFT the y is upside down bearingPt.y = 
    pCentrePt.y - pRadius * cos(bearingInRads); 
    // * Extra Explanation: The TFT is the graphical display I'm using and it
    // * calculates x & y from the top left of screen (portrait mode) as (0,0)
    // * ...so by Subtracting from the Y orgin...I flip it vertically
    // * Other folks using x,y as increasing to the right and up respectively
    // * would keep the plus sign after the pCentrePt.y
    // *************************************************************************

    // ***************************************************************
    // * This part will change for the final product...but leaving
    // * it because when call numerous times it shows it working for
    // * a number of different quadrants (displaying yellow degrees text)
    tft.fillCircle( bearingPt.x, bearingPt.y, 5, RED); 
    tft.setCursor( bearingPt.x, bearingPt.y );
    tft.setTextSize( 1 );
    tft.setTextColor( YELLOW );
    tft.print( pBearingInDegrees );

    TSPoint innerPt;
    innerPt.x = pCentrePt.x + pRadius/2 * sin(bearingInRads);
    innerPt.y = pCentrePt.y - pRadius/2 * cos(bearingInRads);
    tft.drawLine(innerPt.x, innerPt.y, bearingPt.x, bearingPt.y, RED);

}

Answer 8

उत्तर बिल्कुल विपरीत होना चाहिए।

X = Xc + rSin (कोण)

Y = Yc + rCos (कोण)

जहां Xc और Yc सर्कल के केंद्र निर्देशांक हैं और r त्रिज्या है।

Answer 9

सिफारिश:

 public static Vector3 RotatePointAroundPivot(Vector3 point, Vector3 
pivot, Vector3 angles)
    {
	    return Quaternion.Euler(angles) * (point - pivot) + pivot;
    }

Answer 10

आप इसका उपयोग कर सकते हैं:

वृत्त का समीकरण जहाँ

(xk) ² + (yv) ² = आर ²

जहां k और v स्थिर है और R त्रिज्या है