(Viertel-)kreis Funktion

[ilonar]

Moin !

Ich habe einen riesigen Datensatz mit Koordinaten. Den möchte ich nun dahingehend auswerten, dass ich mehrere Viertelkreisfunktionen (alle mit dem selben Mittelpunkt, bloß immer kleiner werdende Radien) habe und dann immer abfrage wie viele Koordinaten zB zwischen Viertelkreis 1 und 2 liegen usw...
Im Prinzip geht das aber auch mit einem ganzen Kreis, denn ich habe sowieso nur Daten in einem Viertel. Die Auswertung würde also auch so klappen.

ich scheitere im Prinzip schon direkt am Anfang: Wie kann ich diese (Viertel-)kreisfunktionen aufstellen?
Ich hatte zunächst versucht mir die einfach mal zu plotten mit:

Code: Alles auswählen

from math import *
import matplotlib.pyplot as plt
import numpy as np

r = 3
x_Kug = np.linspace(0, 1, 100)
y_Kug = []
for i in x_Kug:
    y_Kug.append(sqrt(r**2-i**2))
    
fig, ax = plt.subplots()
ax.plot(x_Kug, y_Kug, 'r-')
plt.show()

Das Problem hierbei ist allerdings:
- es ist kein Viertelkreis (sondern ein drittel? warum denn kein ganzer?)
- mein Mittelpunkt soll eigentlich bei 8 sein, wie kann ich ihm das sagen?
dementsprechend hätte ich gerne eine Achsenbeschränkung von 0-8 auf x- und y- Achse, allerdings sieht man da in meinem Beispiel gar nichts.

Sorry, falls das eine dumme Frage ist, aber ich sitze schon seit 2 Tagen dran und komme irgendwie nicht richtig voran.
Danke für die Hilfe,
Liebe Grüße,
Ilona

[Zizibee]

Vielleicht sehe ich das ja zu einfach, aber warum berechnest du nicht die Abstände deiner Koordinaten zum Kreismittelpunkt mit dem Satz von Pythagoras? Danach kannst du dann die Koordinaten anhand der Abstände gruppieren.

[einfachTobi]

So wie du die Aufgabe darstellst lässt es sich das erreichen, was du vermutlich erreichen willst:

habe und dann immer abfrage wie viele Koordinaten z. B zwischen Viertelkreis 1 und 2 liegen usw...

Die Antwort ist leicht: Es sind unendlich viele Koordinaten dazwischen. Das ist aber nicht das, was du meinst. Welche Koordinaten willst du genau prüfen? Ganzzahlige Koordinaten?
Unabhängig davon solltest du ein Numpy-Array nicht mit einer Schleife durchlaufen. Du kannst die Operation auch gleich auf das ganze Array anwenden:

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot as plt

xm = 8
ym = 8
r = 2
x = np.linspace(xm-r, xm+r, 100)
y = np.linspace(ym-r, ym+r, 100)
X, Y = np.meshgrid(x,y)
F = (X-xm)**2 + (Y-ym)**2 - r*r
plt.contour(X, Y, F, [0])
plt.scatter(xm, ym, marker='x')
plt.axis("equal")
plt.show()

Edit: Irgendwie verplant, dass es nur ein Viertel sein soll:

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot as plt

xm = 8
ym = 8
r = 2
x = np.linspace(xm, xm+r, 100)
y = np.sqrt(r*r - (x-xm)**2) + ym
plt.plot(x, y)
plt.scatter(xm, ym, marker='x')
plt.axis("equal")
plt.show()

Diskrete Koordinaten kannst du tatsächlich einfach prüfen, indem du den Abstand zum Kreismittelpunkt berechnest und mit den Radien deiner umschließenden Kreise vergleichst.

[nezzcarth]

Die Antwort ist leicht: Es sind unendlich viele Koordinaten dazwischen. Das ist aber nicht das, was du meinst. Welche Koordinaten willst du genau prüfen? Ganzzahlige Koordinaten?

In dem Teil, den du gekürzt hast, steht, dass es sich um Koordinaten aus einem konkreten Datensatz handelt, die für die Prüfung herangezogen werden sollen. Die Frage wäre also dann vielleicht eher, welcher Art die Koordinaten in dem Datensatz sind.

[ilonar]

Vielleicht sehe ich das ja zu einfach, aber warum berechnest du nicht die Abstände deiner Koordinaten zum Kreismittelpunkt mit dem Satz von Pythagoras? Danach kannst du dann die Koordinaten anhand der Abstände gruppieren.

Das ist natürlich clever. Damit wäre das Problem ganz easy gelöst.
Manchmal denkt man eben doch zu kompliziert.
Danke !

Die Antwort ist leicht: Es sind unendlich viele Koordinaten dazwischen. Das ist aber nicht das, was du meinst. Welche Koordinaten willst du genau prüfen? Ganzzahlige Koordinaten?

In dem Teil, den du gekürzt hast, steht, dass es sich um Koordinaten aus einem konkreten Datensatz handelt, die für die Prüfung herangezogen werden sollen. Die Frage wäre also dann vielleicht eher, welcher Art die Koordinaten in dem Datensatz sind.

es sind ganzzahlige Koordinaten Also probiere ich mal das von Zizibee
Danke euch!

[einfachTobi]

@nezzcarth: Das habe ich mea culpa überlesen. Damit erübrigt sich das natürlich.
@ilnar: Bedenke auch dabei, dass du alle Abstände "gleichzeitig" berechnen kannst und nicht über dein Array iterieren musst. Sowas in der Art sollte also zum Ziel führen:

Code: Alles auswählen

punkte = np.array([[6, 4], [2, 4], [8.2, 8.2], [0, 0], [8, 9], [10, 8]])
abstaende = np.linalg.norm(punkte - np.array([xm, ym]), axis=1)
print(abstaende[abstaende < r].size)