Java GUI Anwendung: Lissajou Figuren

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Java GUI Anwendung: Lissajou Figuren

    Durch räumliche Überlagerung harmonischer Schwingungen entstehen
    die, nach dem französichen Physiker Jules Antoine Lissasjous (1822–1880) benannten,
    Lissajou-Figuren. Diese Figuren zeigen sich z. B. wenn bei einem Oszilloskop
    sowohl am Eingang für die x-, als auch für die y-Ablenkung eine harmonische
    Wechselspannung angelegt wird.

    //Voraussetzung: Java3D

    Quellcode

    1. package Lissajou;
    3. import java.awt.*;
    4. import java.awt.event.*;
    5. import javax.vecmath.*;
    7. public class LissajouApplication {
    9. public static int xPeriod = 1, yPeriod = 1;
    10. public static boolean cancel=false;
    11. public static boolean trajectory;
    13. public static void main(String[] args) {
    14. new LissajouGUI(800, 600);
    15. }
    17. @SuppressWarnings("serial")
    18. static class LissajouGUI extends Frame {
    19. private LissaJouCanvas canvas = new LissaJouCanvas();
    21. /**
    22. * Konstruktor der GUI
    23. */
    24. public LissajouGUI(int width, int height) {
    25. super("Lissajou Figures");
    27. //Optionen fuer die Zeichenflaeche
    28. canvas.setBackground(Color.LIGHT_GRAY);
    29. canvas.setSize(width, height);
    32. //Fenster schliessen
    33. addWindowListener(new WindowAdapter() {
    34. public void windowClosing(WindowEvent e) {
    35. System.exit(0);
    36. }
    37. });
    39. //Layout Initialisierung
    40. GridBagLayout gridB = new GridBagLayout();
    41. GridBagConstraints layout = new GridBagConstraints();
    42. setLayout(gridB);
    45. layout.gridwidth = 1;
    46. layout.gridheight = 8;
    47. layout.gridx = 1;
    48. layout.gridy = 1;
    50. //Layout defaults
    51. layout.fill = GridBagConstraints.BOTH; //horizontal und vertikal auf MAX
    52. gridB.setConstraints(canvas, layout);
    53. add(canvas);
    55. //Hier beginnt die rechte Spalte
    56. layout.gridheight = 1;
    57. layout.gridx = 2;
    58. layout.gridy = 1;
    60. // Label x- period
    61. Label labelx = new Label("x-period");
    62. gridB.setConstraints(labelx, layout);
    63. add(labelx);
    64. layout.gridy++;
    66. // Choice x-period
    67. Choice xxx = new Choice();
    68. for (int x = 1; x <= 16; x += 1)
    69. xxx.add(x + "");
    70. xxx.addItemListener(new ItemAdapter() {
    71. public void itemStateChanged(ItemEvent event) {
    72. xPeriod = ((Choice) event.getSource()).getSelectedIndex() + 1;
    73. System.out.println("x-periode: "+xPeriod);
    74. }
    75. });
    76. gridB.setConstraints(xxx, layout);
    77. add(xxx);
    78. layout.gridy++;
    80. // Label y-Period
    81. Label labely = new Label("y-period");
    82. gridB.setConstraints(labely, layout);
    83. add(labely);
    84. layout.gridy++;
    86. // Choice y-period
    87. Choice yyy = new Choice();
    88. for (int y = 1; y <= 16; y += 1)
    89. yyy.add(y + "");
    90. gridB.setConstraints(yyy, layout);
    91. yyy.addItemListener(new ItemAdapter() {
    92. public void itemStateChanged(ItemEvent event) {
    93. yPeriod = ((Choice) event.getSource()).getSelectedIndex() + 1;
    94. System.out.println("y-periode: "+yPeriod);
    95. }
    96. });
    97. add(yyy);
    98. layout.gridy++;
    100. // checkBox trajectory
    101. Checkbox checkTrajectory = new Checkbox("show trajectory");
    102. gridB.setConstraints(checkTrajectory, layout);
    103. checkTrajectory.addItemListener(new ItemAdapter() {
    104. public void itemStateChanged(ItemEvent event) {
    105. Checkbox tmp = (Checkbox) event.getSource();
    106. System.out.println("Trajectory: "+tmp.getState());
    107. if (tmp.getState())
    108. trajectory = true;
    109. else
    110. trajectory = false;
    111. }
    112. });
    113. add(checkTrajectory);
    114. layout.gridy++;
    116. // Clear Button
    117. Button clearBut = new Button("clear");
    118. gridB.setConstraints(clearBut, layout);
    119. clearBut.addActionListener(new ActionAdapter() {
    120. public void actionPerformed(ActionEvent e) {
    121. canvas.repaint();
    122. }
    123. });
    124. add(clearBut);
    125. layout.gridy++;
    127. // Stop Button
    128. Button stopBut = new Button("Stop");
    129. gridB.setConstraints(stopBut, layout);
    130. stopBut.addActionListener(new ActionAdapter() {
    131. public void actionPerformed(ActionEvent e) {
    132. LissajouApplication.cancel = true;
    133. }
    134. });
    135. add(stopBut);
    136. layout.gridy++;
    138. // Start Button
    139. Button startBut = new Button("Start");
    140. gridB.setConstraints(startBut, layout);
    141. startBut.addActionListener(new ActionAdapter() {
    142. public void actionPerformed(ActionEvent e) {
    143. canvas.startAnimation();
    144. }
    145. });
    146. add(startBut);
    147. setSize(width,height);
    148. setLocation(150,100);
    149. setVisible(true);
    150. pack();
    151. }
    153. abstract class ItemAdapter extends Object implements ItemListener {
    154. public abstract void itemStateChanged(ItemEvent event);
    155. }
    157. abstract class ActionAdapter extends Object implements ActionListener {
    158. public abstract void actionPerformed(ActionEvent e);
    159. }
    160. }
    162. @SuppressWarnings("serial")
    163. static class LissaJouCanvas extends Canvas implements Runnable {
    164. /**
    165. * startet den Thread fuer die Animation
    166. */
    167. public void startAnimation() {
    168. try {
    169. LissajouApplication.cancel = false;
    170. new Thread(this).start();
    171. } catch (Exception e){}
    172. }
    174. // public void repaint() {
    175. // wird zum clearen benutzt.. daher ist das original OK
    176. // }
    178. /**
    179. * zeichnet die Lissajou Kurve wieder und wieder
    180. */
    181. public void run() {
    182. while(true) //Wenn fertig gezeichnet, dann zeichne nochmal
    183. new Lissajou(getGraphics(), this.getWidth()/2, this.getHeight()/2, xPeriod, yPeriod, trajectory);
    184. }
    185. }
    187. static class Lissajou {
    189. /**
    190. * Konstruktor - Zeichnet die Lissajou Figur
    191. * @param g Graphics Objekt
    192. * @param startX
    193. * @param startY
    194. * @param xPeriod X Position
    195. * @param yPeriod Y Position
    196. * @param trajectory Kometenschweif
    197. */
    198. public Lissajou(Graphics g, int startX, int startY, int xPeriod, int yPeriod, boolean trajectory) {
    199. final double deltaT = 0.01;
    200. double t;
    202. Point2d p;
    203. Vector2d v;
    205. int kgv =Kgv(xPeriod,yPeriod);
    207. int stop = (int)(kgv/deltaT); //Abbruchbedingug
    208. int[] x = new int[stop+1], y = new int[stop+1]; //Polyline Array
    210. for(int s=1, counter=0; s<=stop && !LissajouApplication.cancel; s++) {
    211. t = s * deltaT;
    212. p = makePoint2d(t, startX, startY, xPeriod, yPeriod);
    213. v = makeVector2d(t, xPeriod, yPeriod);
    215. //Kometenschweif anzeigen?
    216. if(LissajouApplication.trajectory) {
    217. x[counter] = (int)p.x;
    218. y[counter] = (int)p.y;
    219. g.drawPolyline(x, y, counter);
    220. counter++;
    221. }
    223. //ueberzeichne mit Hintergrundfarbe
    224. g.fillPolygon(arrow(p,v,5,2));
    225. g.setColor(Color.LIGHT_GRAY);
    227. //Das ist eine menschlich sichtbare Animation, also schlafe ein wenig
    228. try {
    229. Thread.sleep(40);
    230. } catch (Exception e) {}
    232. //ueberzeichne schwarz
    233. g.fillPolygon(arrow(p,v,5,2));
    234. g.setColor(Color.BLACK);
    235. }
    236. }
    238. /**
    239. * zeichnet einen gerichteten Pfeil
    240. * @param pos Position
    241. * @param dir Richtung
    242. * @param s hoehe
    243. * @param r breite
    244. * @return Polygon
    245. */
    246. private Polygon arrow(Point2d pos, Vector2d dir, double s, double r) {
    247. dir.normalize();
    248. dir.scale(s);
    249. Vector2d vec = new Vector2d(-dir.y, dir.x);
    250. dir.scale(2 * r);
    251. Polygon polygon = new Polygon();
    252. polygon.addPoint((int) (pos.x + vec.x), (int) (pos.y + vec.y));
    253. polygon.addPoint((int) (pos.x + dir.x), (int) (pos.y + dir.y));
    254. polygon.addPoint((int) (pos.x - vec.x), (int) (pos.y - vec.y));
    255. return polygon;
    256. }
    258. private Point2d makePoint2d(double t,int startX, int startY, int xPeriod,int yPeriod){
    259. Point2d ret = new Point2d();
    260. ret.x = startX + startX *Math.cos((2*Math.PI/xPeriod)*t);
    261. ret.y = startY + startY *Math.sin((2*Math.PI/yPeriod)*t);
    262. return ret;
    263. }
    265. private Vector2d makeVector2d(double t, int xPeriod,int yPeriod){
    266. Vector2d ret = new Vector2d();
    267. ret.x = -1*(2*Math.PI/xPeriod)*Math.sin((2*Math.PI/xPeriod)*t);
    268. ret.y = (2*Math.PI/yPeriod)*Math.cos((2*Math.PI/yPeriod)*t);
    269. return ret;
    270. }
    272. private int Kgv(int xPeriod, int yPeriod) {
    273. int tmp = xPeriod * yPeriod;
    274. return tmp/ggt(xPeriod, yPeriod);
    275. }
    276. /**
    277. * kleinstes gemeinsames Vielfaches
    278. * groesster gemeinsamer Teiler
    279. * @param a Zahl 1
    280. * @param b Zahl 2
    281. * @return ggT
    282. */
    283. private int ggt(int a, int b) {
    284. if(a % b == 0)
    285. return b;
    286. else
    287. return ggt(b, a % b);
    288. }
    289. }
    291. }
    Alles anzeigen
    Bilder

    • lissajou-figuren-java.png

      46,31 kB, 646×466, 1.791 mal angesehen
    Dateien

    • lissajou.jar

      (65,09 kB, 503 mal heruntergeladen, zuletzt: )