Bir daire içindeki noktaların konumunu hesaplamak

Şu anda bu konuda biraz boş boş düşünüyorum. Merkezden ve birbirlerinden eşit uzaklıkta olduklarını varsayarak, merkezi bir nokta etrafındaki noktaların konumunu hesaplamam gereken bir problemim var.

Puanların sayısı değişkendir, bu yüzden DrawCirclePoints(int x) eminim ki basit bir çözüm vardır, ancak hayatım boyunca bunu göremiyorum :)

Merkezi çember üzerinde açısı teta bir nokta (x0,y0)ve çapı olan rbir (x0 + r cos theta, y0 + r sin theta). Şimdi theta0 ile 2pi arasında eşit aralıklarla yerleştirilmiş değerleri seçin .

Bir yarıçap uzunluğu r ve radyan cinsinden bir açı t ve bir çemberin merkezi (h, k) verildiğinde, çevredeki bir noktanın koordinatlarını aşağıdaki gibi hesaplayabilirsiniz (bu sözde koddur, bunu kendi dil):

float x = r*cos(t) + h;
float y = r*sin(t) + k;

İşte C # kullanan bir çözüm:

void DrawCirclePoints(int points, double radius, Point center)
{
    double slice = 2 * Math.PI / points;
    for (int i = 0; i < points; i++)
    {
        double angle = slice * i;
        int newX = (int)(center.X + radius * Math.Cos(angle));
        int newY = (int)(center.Y + radius * Math.Sin(angle));
        Point p = new Point(newX, newY);
        Console.WriteLine(p);
    }
}

Örnek çıktı DrawCirclePoints(8, 10, new Point(0,0));:

{X=10,Y=0}
{X=7,Y=7}
{X=0,Y=10}
{X=-7,Y=7}
{X=-10,Y=0}
{X=-7,Y=-7}
{X=0,Y=-10}
{X=7,Y=-7}

İyi şanslar!

Yukarıdaki cevaplardan birini temel alarak, işte Java / Android örneği:

protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    RectF bounds = new RectF(canvas.getClipBounds());
    float centerX = bounds.centerX();
    float centerY = bounds.centerY();

    float angleDeg = 90f;
    float radius = 20f

    float xPos = radius * (float)Math.cos(Math.toRadians(angleDeg)) + centerX;
    float yPos = radius * (float)Math.sin(Math.toRadians(angleDeg)) + centerY;

    //draw my point at xPos/yPos
}

Dairesel bir yola bir sayı yerleştirme

// variable

let number = 12; // how many number to be placed
let size = 260; // size of circle i.e. w = h = 260
let cx= size/2; // center of x(in a circle)
let cy = size/2; // center of y(in a circle)
let r = size/2; // radius of a circle

for(let i=1; i<=number; i++) {
  let ang = i*(Math.PI/(number/2));
  let left = cx + (r*Math.cos(ang));
  let top = cy + (r*Math.sin(ang));
  console.log("top: ", top, ", left: ", left);
}

Bunu web üzerinden yapmak zorundaydım, işte @ scottyab'ın yukarıdaki cevabının bir kahve taslağı versiyonu :

points = 8
radius = 10
center = {x: 0, y: 0}

drawCirclePoints = (points, radius, center) ->
  slice = 2 * Math.PI / points
  for i in [0...points]
    angle = slice * i
    newX = center.x + radius * Math.cos(angle)
    newY = center.y + radius * Math.sin(angle)
    point = {x: newX, y: newY}
    console.log point

drawCirclePoints(points, radius, center)

Tamamlama uğruna, "merkezi bir nokta etrafındaki noktaların konumu (merkezden eşit uzaklıkta olduklarını varsayarak)" olarak tanımladığınız şey, "Polar Koordinatlar" dan başka bir şey değildir. Ve yolda için soruyorsunuz kutupsal ve kartezyen koordinatlar arasındaki dönüştürme olarak verilir x = r*cos(t), y = r*sin(t).

PHP Çözümü:

class point{
    private $x = 0;
    private $y = 0;
    public function setX($xpos){
        $this->x = $xpos;
    }
    public function setY($ypos){
        $this->y = $ypos;
    }
    public function getX(){
        return $this->x;
    }
    public function getY(){
        return $this->y;
    }
    public function printX(){
        echo $this->x;
    }
    public function printY(){
        echo $this->y;
    }
}

function drawCirclePoints($points, $radius, &$center){
    $pointarray = array();
    $slice = (2*pi())/$points;
    for($i=0;$i<$points;$i++){
        $angle = $slice*$i;
        $newx = (int)($center->getX() + ($radius * cos($angle)));
        $newy = (int)($center->getY() + ($radius * sin($angle)));
        $point = new point();
        $point->setX($newx);
        $point->setY($newy);
        array_push($pointarray,$point);
    }
    return $pointarray;
}

Noktalarınızın her biri arasındaki açı 2Pi/xöyle olacaktır ki, noktalar n= 0 to x-1için tanımlı bir 0 noktasından açı olduğunu söyleyebilirsiniz 2nPi/x.

İlk noktanızın konumunda olduğunu varsayarsak (r,0)(burada r, merkez noktasından uzaklıktır), o zaman merkezi noktaya göre konumlar şöyle olacaktır:

rCos(2nPi/x),rSin(2nPi/x)

Java'da Çalışma Çözümü:

import java.awt.event.*;
import java.awt.Robot;

public class CircleMouse {

/* circle stuff */
final static int RADIUS = 100;
final static int XSTART = 500;
final static int YSTART = 500;
final static int DELAYMS = 1;
final static int ROUNDS = 5;

public static void main(String args[]) {

    long startT = System.currentTimeMillis();
    Robot bot = null;

    try {
        bot = new Robot();
    } catch (Exception failed) {
        System.err.println("Failed instantiating Robot: " + failed);
    }
    int mask = InputEvent.BUTTON1_DOWN_MASK;

    int howMany = 360 * ROUNDS;
    while (howMany > 0) {
        int x = getX(howMany);
        int y = getY(howMany);
        bot.mouseMove(x, y);
        bot.delay(DELAYMS);
        System.out.println("x:" + x + " y:" + y);
        howMany--;
    }

    long endT = System.currentTimeMillis();
    System.out.println("Duration: " + (endT - startT));

}

/**
 * 
 * @param angle
 *            in degree
 * @return
 */
private static int getX(int angle) {
    double radians = Math.toRadians(angle);
    Double x = RADIUS * Math.cos(radians) + XSTART;
    int result = x.intValue();

    return result;
}

/**
 * 
 * @param angle
 *            in degree
 * @return
 */
private static int getY(int angle) {
    double radians = Math.toRadians(angle);
    Double y = RADIUS * Math.sin(radians) + YSTART;
    int result = y.intValue();

    return result;
}
}

İşte Ryukarıdaki @Pirijan cevabına dayalı bir versiyon.

points <- 8
radius <- 10
center_x <- 5
center_y <- 5

drawCirclePoints <- function(points, radius, center_x, center_y) {
  slice <- 2 * pi / points
  angle <- slice * seq(0, points, by = 1)

  newX <- center_x + radius * cos(angle)
  newY <- center_y + radius * sin(angle)

  plot(newX, newY)
}

drawCirclePoints(points, radius, center_x, center_y)

İşte javascript ile bir çember üzerinde bir noktayı, çemberin tepesinden açıyı (derece) hesaplayarak nasıl buldum.

  const centreX = 50; // centre x of circle
  const centreY = 50; // centre y of circle
  const r = 20; // radius
  const angleDeg = 45; // degree in angle from top
  const radians = angleDeg * (Math.PI/180);
  const pointY = centreY - (Math.cos(radians) * r); // specific point y on the circle for the angle
  const pointX = centreX + (Math.sin(radians) * r); // specific point x on the circle for the angle

Daniel'in yukarıdaki cevabına dayanarak, işte Python3 kullanarak benim almam.

import numpy


def circlepoints(points,radius,center):
    shape = []
    slice = 2 * 3.14 / points
    for i in range(points):
        angle = slice * i
        new_x = center[0] + radius*numpy.cos(angle)
        new_y = center[1] + radius*numpy.sin(angle)

        p = (new_x,new_y)
        shape.append(p)

    return shape

print(circlepoints(100,20,[0,0]))