Nice To Know: Kollinearität von drei Punkten im Dreidimensionalen

Um zu bestimmen, ob drei Punkte im Dreidimensionalen auf einer Geraden liegen, also kollinear sind, lässt sich eine Flächenberechnung des Dreiecks missbrauchen, die in folgender Formel gegeben ist:



Drei Punkte x, y und z sind kollinear, wenn die Fläche des durch sie erzeugten Dreieckes 0 ist. Da also nur interessant ist, ob die Fläche 0 ist oder nicht, kann man sich an der Formel das Dividieren durch zwei und das Wurzel ziehen sparen. Das ändert nichts an der Tatsache, ob die Dreiecksfläche 0 oder nicht 0 ist.

Damit lässt sich folgender Code in Java zur Überprüfung auf Kollinearität schreiben. Die zweite Methode berechnet die Determinante der Matrix nach der Regel von Sarrus. Die Methode isColinear verzichtet auch auf das Quadrieren der Determinanten, was auch nichts an der Dreiecksfläche hinsichtlich 0 oder nicht 0 ändert.

public static boolean isCollinear
        (Point p1, Point p2, Point p3) {
  double d[][] = null;

  d = new double[][]{
            {p1.getX(), p2.getX(), p3.getX()},
            {p1.getY(), p2.getY(), p3.getY()},
            {1, 1, 1}
          };
  if (determinant(d) != 0.0) {
    return false;
  }
  d = new double[][]{
            {p1.getY(), p2.getY(), p3.getY()},
            {p1.getZ(), p2.getZ(), p3.getZ()},
            {1, 1, 1}
          };
  if (determinant(d) != 0.0) {
    return false;
  }
  d = new double[][]{
            {p1.getZ(), p2.getZ(), p3.getZ()},
            {p1.getX(), p2.getX(), p3.getX()},
            {1, 1, 1}
          };
  if (determinant(d) != 0.0) {
    return false;
  }
  return true;
}

public static double determinant
        (double[][] matrix) {
  return
    (matrix[0][0] * matrix[1][1] * matrix[2][2] +
     matrix[0][1] * matrix[1][2] * matrix[2][0] +
     matrix[0][2] * matrix[1][0] * matrix[2][1])
        -
    (matrix[0][2] * matrix[1][1] * matrix[2][0] +
     matrix[0][1] * matrix[1][0] * matrix[2][2] +
     matrix[0][0] * matrix[1][2] * matrix[2][1]);
}

(Der Eintrag entstand um diesen Eintrag abzukürzen und auf die dritte Dimension zu erweitern.)

Nice To Know: Division in Java

So, ein für alle Mal. Endlich zum Hinter die Ohren schreiben:

1 / 2 = 0
1.0 / 2 = 0.5
1 / 2.0 = 0.5
1.0 / 2.0 = 0.5
((double) 1) / 2 = 0.5
1 / ((double) 2) = 0.5
((double) 1) / ((double) 2) = 0.5

1 * 2 = 2
1.0 * 2 = 2.0
1 * 2.0 = 2.0
1.0 * 2.0 = 2.0
((double) 1) * 2 = 2.0
1 * ((double) 2) = 2.0
((double) 1) * ((double) 2) = 2.0

1 / 2 * 2 = 0
1 / 2 * 2.0 = 0.0
1 / (2 * 2.0) = 0.25
1 / 2.0 * 2 = 1.0
1 / (2.0 * 2) = 0.25
1.0 / 2 * 2 = 1.0
1.0 / (2 * 2) = 0.25

jBeepMaker

Mit jBeepMaker können der Windows-Kiste ein paar tolle (..) Töne entlockt werden, sofern man die entsprechenden Hertz-Zahlen kennt. Aber ist ja auch nur eine Beta. Vorteil: Läuft ohne Soundkarte! Nachteil: nur auf Windows. Aber lustig ist es allemal, wenn man es noch als kleine Scareware verpacken würde, mit einem Timer. Ein Leiser-Stellen gibt es für dieses Beepen nicht :D

Die ausführbare JAR-Datei findet ihr bei SourceForge.net.

jHoren – Task Planner

Ich muss mal lobend ein Programm erwähnen. Mit jHoren ist ein wirklich gutes, Java-basiertes Aufgabenverwaltungsprogramm entstanden. Ich probiere es gerade aus und werde es auch weiterhin nutzen. Denn ToDo-Listen abhaken, auch virtuell, macht glücklich. Und dank Java, unter Windows und *nix gleichermaßen .. vermutlich auch bei dieser Apfelfirma...

Hier eine Feature-Liste:

Aufgabenverwaltung

• Erstellen von Aufgaben
• Löschen von Aufgaben
• Bearbeiten von Aufgaben
• Beenden von Aufgaben
• hierarchisches Verwalten von Aufgaben

Prioritätsberechnung

• dynamisch in Abhängigkeit von der zeitlichen Nähe der Deadline
• in Abhängigkeit von einer Basispriorität
• in Abhängigkeit von einem angegebenen Berechnungsmodell
• Typisierung
• Verwaltung von Aufgabentypen wie Projekt, Teilprojekt, Meilenstein, Ziel, Aufgabe, ...

Zeiterfassung / Heuristik

• für jede Aufgabe sollen Arbeitszeiten erfasst werden können diese Zeiten sollen über Aufgaben(-bäumen) summiert darstellbar sein an Hand von bisherigen Arbeitszeiten sollen Schätzungen für nachfolgende ähnliche Aufgaben erfolgen

Abhängigkeiten von Aufgaben

• Abhängigkeiten haben Einfluss auf Prioritätsberechnung
• Visualisierung von Aufgaben/Zeitplänen
• Visualisierung als Gantt-Diagramm
• übersichtlicher Kalender
• andere übersichtliche Visualisierungen

Druckfunktionen

• Drucken von Aufgabenplänen mit den nächsten Aufgaben
• Drucken weiterer Berichte

RotatingLabel

Wer seine Platten digitalisiert hat und dann als z.B. MP3 anhört könnte so einiges Vermissen: Platten umdrehen (vielleicht eher nicht), die Platten berühren (soll eine sinnliche Erfahrung sein), das rotierende Label der Platte zu beobachten, usw. usf.

Für letzteres gibt es jetzt eine Abhilfe. Ein kleines Programm in das man sich die Bilddatei des Labels laden kann und darin wird es dann in der entsprechenden Geschwindigkeit rotiert (33¹/₃rpm, 45rpm, 78rpm). Man kann es auch benutzen um die beschriftete Seite einer CD rotieren zu lassen.

Es ist die erste Version, sollte eigentlich grundlegend alles funktionieren. Trotzdem erstmal als Beta-Version. Hinweise könnt ihr mir gerne senden. Das Programm sollte auf jedem Betriebssystem laufen, dass eine Java Laufzeitumgebung von mindestens Version 6 hat.

Der Download kann hier erfolgen. Das Passwort zum Entpacken der RAR-Datei lautet „rotlab“. Ein Beispiel-Label ist beigelegt.

So, dann kann ich ja jetzt gespannt sein, was die Internetwelt dazu zu sagen hat.

Maus-O-Meter in Java

Vor einiger Zeit habe ich mich gefragt, ob man den Mouse-O-Meter nicht auch in Java implementieren könnte, hatte aber bis eben noch nicht das richtige Werkzeug dafür gefunden.

Jetzt aber hat mir Galileo Computing einen Tip gegeben. Des Rätsels Lösung ist die Klasse MouseInfo und so grob funktioniert es dann:

import java.awt.MouseInfo;

public class MouseInfoTest
{
  public static void main(String[] args)
  {
    while(true)
    {
      System.out.println(
        MouseInfo.getPointerInfo()
                 .getLocation() 
                 .toString());
      try{
      Thread.sleep(100);
      }
      catch(Exception ex)
      {}
    }
  }
}

Das Programm läuft dann auf der Konsole und gibt alle 0,1 Sekunden die aktuelle Position des Mauszeigers am Bildschirm aus. Mit Strg-C wird die Endlosschleife gestoppt. Aus den Pixelpositionen lässt sich dann dank der Physik die Geschwindigkeit ermitteln. Und daraus dann wieder der zurückgelegte Weg. Kommt ganz schön was zusammen. Ein paar Mal den Mauszeiger auf dem Bildschirm um die Welt geschrubbt.