Zeichnen Sie eine Kugel mit 3D-Pixel (Voxel-Sculpting -)

Ich glaube nicht, dass das ausführen der midpoint circle Algorithmus auf jeder Ebene, werden Sie die gewünschten Ergebnisse, wenn Sie erreichen die Polen, wie Sie haben Lücken in der Oberfläche, wo die LEDs nicht Leuchten. Dies kann das Ergebnis, die Sie wollen, jedoch so, dass wäre bis zur ästhetik. Dieser Beitrag ist auf der Basis der Mittelpunkt-Kreis-Algorithmus, um zu bestimmen, den radius der Schichten in der Mitte durch zwei senkrechte oktanten, und dann bei der Zeichnung der einzelnen Kreise, auch die Punkte für die polar-oktanten.

Ich denke, basierend auf dem @Nick Udall ' s Kommentar und Antwort hier verwenden des Kreis-Algorithmus, um zu bestimmen, den radius Ihrer horizontalen Scheibe wird die Arbeit mit einer Modifikation, die ich vorgeschlagen, in einem Kommentar auf seine Antwort. Der Kreis-Algorithmus geändert werden sollte, um nehmen als Eingabe einen ersten Fehler und zeichnen auch die zusätzlichen Punkte für die polar-oktanten.

• Zeichnen Sie die standard-Kreis-Algorithmus Punkte auf y0 + y1 und y0 - y1: x0 +/- x, z0 +/- z, y0 +/- y1, x0 +/- z, z0 +/- x, y0 +/- y1, insgesamt 16 Punkte. Dies bildet den Hauptteil der vertikalen Sphäre.
• Zusätzlich zeichnen Sie die Punkte x0 +/- y1, z0 +/- x, y0 +/- z und x0 +/- x, z0 +/- y1, y0 +/- z, insgesamt 16 Punkte, die form der Polkappen für die Kugel.

Indem die äußeren Algorithmus-Fehler in der Kreis-Algorithmus, der es erlaubt, die für die sub-voxel-Anpassung der beiden Ebenen Kreis. Ohne die Fehler in den inneren Algorithmus, der äquator des Kreises angenähert werden, um einen Zylinder, und jede Sphäre angenähert Gesicht auf der x -, y-und z-Achsen bilden ein Quadrat. Mit der Fehler enthalten, jedes Gesicht gegeben, einen ausreichend großen radius angenähert werden als mit einem gefüllten Kreis.

Dem folgenden code wird geändert von Wikipedia Midpoint circle Algorithmus. Die DrawCircle Algorithmus hat die Nomenklatur geändert, um den Betrieb in der xz-Ebene, neben der Dritten Ausgangspunkt y0, das y-offset y1, und anfängliche Fehler error0. DrawSphere wurde geändert von derselben Funktion nehmen Sie die Dritte Ausgangspunkt y0 und fordert DrawCircle eher als DrawPixel

public static void DrawCircle(int x0, int y0, int z0, int y1, int radius, int error0)
{
  int x = radius, z = 0;
  int radiusError = error0; //Initial error state passed in, NOT 1-x

  while(x >= z)
  {
    //draw the 32 points here.
    z++;
    if(radiusError<0)
    {
      radiusError+=2*z+1;
    }
    else
    {
      x--;
      radiusError+=2*(z-x+1);
    }
  }
}

public static void DrawSphere(int x0, int y0, int z0, int radius)
{
  int x = radius, y = 0;
  int radiusError = 1-x;

  while(x >= y)
  {
    //pass in base point (x0,y0,z0), this algorithm's y as y1,
    //this algorithm's x as the radius, and pass along radius error.
    DrawCircle(x0, y0, z0, y, x, radiusError);
    y++;
    if(radiusError<0)
    {
      radiusError+=2*y+1;
    }
    else
    {
      x--;
      radiusError+=2*(y-x+1);
    }
  }
}

Für eine Kugel mit radius 4 (die eigentlich erfordert 9x9x9), würde dies führen Sie drei Iterationen der DrawCircle routine, mit der ersten Zeichnung einer typischen radius: 4 Lochkreis (in drei Schritten), die zweite Zeichnung einen radius von 4 Kreis mit dem ersten Fehler von 0 (drei Schritte), und dann die Dritte Zeichnung einen Kreis mit radius 3 ersten Fehler 0 (drei Schritte). Dass am Ende neun Punkte berechnet, Zeichnung 32 Pixel jedes.
Das macht 32 (Punkte pro Kreis) x 3 (addieren oder subtrahieren Operationen pro Punkt) + 6 (addition, Subtraktion, shift-Operationen pro iteration) = 102 addieren, subtrahieren, oder shift-Operationen pro Punkt berechnet. In diesem Beispiel, dass die 3 Punkte für jeden Kreis = 306 Vorgänge pro Schicht. Der radius-Algorithmus fügt auch 6 Vorgänge pro Schicht und 3-mal iteriert, so 306 + 6 * 3 = 936 Grundrechenarten für das Beispiel wird ein radius von 4.
Die Kosten hier ist, dass Sie immer wieder einige Pixel ohne die zusätzliche Bedingung prüft (d.h. x = 0, y = 0 oder z = 0), so dass, wenn Sie Ihre I/O ist langsam, Sie können es besser das hinzufügen der Bedingung überprüft. Vorausgesetzt, alle LEDs wurden geräumt an den start, das Beispiel Kreis setzen würden, 288 LEDs, während es viele weniger LED, die eigentlich leuchtet, durch wiederholen Sie die Sätze.

Es sieht aus wie wäre dies besser als der bruteforce-Methode für alle Lebensbereiche, die passen würde in der 8x8x8-raster, sondern die bruteforce-Methode müsste konsistente timing unabhängig von radius, während diese Methode verlangsamt beim zeichnen großen radius Sphären, wo nur ein Teil angezeigt. Da das display cube erhöht in der Auflösung, aber diese timing-Algorithmus wird konsistent bleiben, während bruteforce erhöhen.

Gerade ein altes q&eine über die Sphäre Mesh, aber die top-Antwort tatsächlich gibt Sie ein kurzes Stück pseudo-code zu generieren, Ihre X -, Y-und Z :

(x, y, z) = (sin(Pi * m/M) cos(2Pi * n/N), sin(Pi * m/M) sin(2Pi * n/N), cos(Pi * m/M))

Überprüfen Sie dieses Q&A für details 🙂
prozedural erzeugen eine Sphäre mesh