Animation eines Körpers auf der schiefen Ebene

[Julbe]

Hallo zusammen,

ich muss für ein Projekt an der Hochschule ein kleines Programm in Java zum Thema "schiefe Ebene" schreiben.
Vorgestellt habe ich mir, dass das man in das Programm Werte eingeben kann, es die fehlenden ausrechnet und man anschließend noch einen Körper eine Ebene runter fahren/rutschen lassen kann.

Ich habe probiert die Animation mit einem Timer zu programmieren, soweit funktionieren bei mir auch die Animation des Körpers aber nur bei 45 Grad. (Bei anderen Winkeln(Geändert in der Klasse) sieht die Animation komisch aus)

Zudem fehlen mir noch die Buttonfunktionen, sodass ich beinflussen kann, wann die Animation startet oder ich diese auch abbrechen oder resetten könnte. (Wie komme ich dazu das ActionEvent aus der Zeichenklasse aus der Hauptklasse aufzurufen?)

Ich füge mal meinen bisherigen Code an, in der Hoffnung, dass einer von euch mir eventuell weiterhelfen kann oder einen besseren/anderen Ansatz weiß.

Hauptfenster:

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.JTextPane;
import javax.swing.ImageIcon;

@SuppressWarnings("serial")
public class GUI_SchiefeEbene extends JFrame {

    private JPanel contentPane;
    private JTextField txtNeigungswinkel;
    private JTextField txtGewicht;
    private JTextField txtReibungskoeffizient;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    GUI_SchiefeEbene frame = new GUI_SchiefeEbene();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public GUI_SchiefeEbene() {
        setTitle("Schiefe Ebene");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 1000, 950);
        setResizable(false);
        setLocationRelativeTo(null);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);
       
        //Felder der Eingabe
        txtNeigungswinkel = new JTextField();
        txtNeigungswinkel.setBounds(230, 150, 141, 32);
        contentPane.add(txtNeigungswinkel);
        txtNeigungswinkel.setColumns(10);
       
        txtGewicht = new JTextField();
        txtGewicht.setBounds(230, 200, 141, 32);
        contentPane.add(txtGewicht);
        txtGewicht.setColumns(10);
       
        txtReibungskoeffizient = new JTextField();
        txtReibungskoeffizient.setBounds(230, 250, 141, 32);
        contentPane.add(txtReibungskoeffizient);
        txtReibungskoeffizient.setColumns(10);
       
        //Beschriftungen für die Eingabefelder
        JLabel lblEingabe = new JLabel("Werteeingabe");
        lblEingabe.setBounds(21, 95, 150, 26);
        contentPane.add(lblEingabe);
       
        JLabel lblNeigungswinkel = new JLabel("Neigungswinkel");
        lblNeigungswinkel.setBounds(21, 150, 159, 26);
        contentPane.add(lblNeigungswinkel);
       
        JLabel lblGewicht = new JLabel("Gewicht");
        lblGewicht.setBounds(21, 200, 92, 26);
        contentPane.add(lblGewicht);
       
        JLabel lblReibungskoeffizient = new JLabel("Reibungskoeffizient");
        lblReibungskoeffizient.setBounds(21, 250, 181, 26);
        contentPane.add(lblReibungskoeffizient);
       
        //Beschriftungen der Ausgabefelder
        JLabel lblWerteausgabe = new JLabel("Werteausgabe");
        lblWerteausgabe.setBounds(21, 305, 181, 26);
        contentPane.add(lblWerteausgabe);
       
        JLabel lblNormalkraft = new JLabel("Normalkraft");
        lblNormalkraft.setBounds(21, 360, 181, 26);
        contentPane.add(lblNormalkraft);
       
        JLabel lblHangabtriebskraft = new JLabel("Hangabtriebskraft");
        lblHangabtriebskraft.setBounds(21, 410, 174, 26);
        contentPane.add(lblHangabtriebskraft);
       
        JLabel lblReibungskraft = new JLabel("Reibungskraft");
        lblReibungskraft.setBounds(21, 460, 181, 26);
        contentPane.add(lblReibungskraft);
       
        JLabel lblBewegungskraft = new JLabel("Beschleunigungskraft");
        lblBewegungskraft.setBounds(21, 510, 207, 26);
        contentPane.add(lblBewegungskraft);
       
        //Felder der Ausgabe
        JTextPane txtNormalkraft = new JTextPane();
        txtNormalkraft.setBounds(230, 360, 141, 32);
        contentPane.add(txtNormalkraft);
       
        JTextPane txtHangabtriebskraft = new JTextPane();
        txtHangabtriebskraft.setBounds(230, 410, 141, 32);
        contentPane.add(txtHangabtriebskraft);
       
        JTextPane txtReibungskraft = new JTextPane();
        txtReibungskraft.setBounds(230, 460, 141, 32);
        contentPane.add(txtReibungskraft);
       
        JTextPane txtBeschleunigungskraft = new JTextPane();
        txtBeschleunigungskraft.setBounds(230, 510, 141, 32);
        contentPane.add(txtBeschleunigungskraft);
       
        //Einheiten der Eingaben
        JLabel lblNeigungswinkelEinheit = new JLabel("\u00B0");
        lblNeigungswinkelEinheit.setBounds(380, 150, 92, 26);
        contentPane.add(lblNeigungswinkelEinheit);
       
        JLabel lblGewichtEinheit = new JLabel("kg");
        lblGewichtEinheit.setBounds(380, 200, 92, 26);
        contentPane.add(lblGewichtEinheit);
       
        //Einheiten der Ausgaben
        JLabel lblNormalkraftEinheit = new JLabel("N");
        lblNormalkraftEinheit.setBounds(380, 360, 92, 26);
        contentPane.add(lblNormalkraftEinheit);
       
        JLabel lblHangabtriebskrafteinheit = new JLabel("N");
        lblHangabtriebskrafteinheit.setBounds(380, 410, 92, 26);
        contentPane.add(lblHangabtriebskrafteinheit);
       
        JLabel lblReibunsgkraftEinheit = new JLabel("N");
        lblReibunsgkraftEinheit.setBounds(380, 460, 92, 26);
        contentPane.add(lblReibunsgkraftEinheit);
       
        JLabel lblBeschleunigungskraftEinheit = new JLabel("N");
        lblBeschleunigungskraftEinheit.setBounds(380, 510, 92, 26);
        contentPane.add(lblBeschleunigungskraftEinheit);
       
        //DHBW LOGO
        JLabel lblDHBWLogo = new JLabel("");
        lblDHBWLogo.setIcon(new ImageIcon("\\\\Mac\\Home\\Documents\\Hochschule\\Informatik\\DHBW Logo.jpeg"));
        lblDHBWLogo.setBounds(21, 697, 181, 181);
        contentPane.add(lblDHBWLogo);
       
        //Zeichenpanel, das mit der Klasse draw_Ebene verbunden ist
        JPanel drawEbene = new zeichnen_EbeneKlotz();      
        drawEbene.setBounds(525, 60, 400, 703);
        contentPane.add(drawEbene);
        drawEbene.setLayout(null);
       
        //Button Information, soll die Methode aus der Klasse GUI_Information aufrufen
        JButton btnInformation = new JButton("Information");
        btnInformation.setBounds(21, 25, 159, 35);
        contentPane.add(btnInformation);
       
       
        //Button Berechnen
        JButton btnBerechnen = new JButton("Berechnen");
        btnBerechnen.addActionListener(new ActionListener(){
               public void actionPerformed(ActionEvent e) {
               
                    //Definition von Hilfsobjekten
                       double EingabeNeigungswinkel;
                    double EingabeGewicht;
                    double EingabeReibungskoeffizient;
                 
                    //Eingabe entegegen nehmen
                    EingabeNeigungswinkel = Double.parseDouble(txtNeigungswinkel.getText());
                    EingabeGewicht = Double.parseDouble(txtGewicht.getText());
                    EingabeReibungskoeffizient = Double.parseDouble(txtReibungskoeffizient.getText());
                   
   
                        Berechnungen.setNeigungswinkel(EingabeNeigungswinkel);
                        Berechnungen.setGewicht(EingabeGewicht);
                        Berechnungen.setReibungskoeffizient(EingabeReibungskoeffizient);
                       
                        //Winkel an draw_Ebene geben
                        zeichnen_EbeneKlotz.setNeigungswinkel(EingabeNeigungswinkel);
                        repaint();
                                           
                    //Rundungsformat festlegen    
                    DecimalFormat f = new DecimalFormat("#0.00");
                   
                    //Ausgabe
                    txtHangabtriebskraft.setText(f.format(Berechnungen.getHangabtriebskraft()));
                    txtNormalkraft.setText(f.format(Berechnungen.getNormalkraft()));
                    txtReibungskraft.setText(f.format(Berechnungen.getReibungskraft()));
                   
                   
        btnBerechnen.setBounds(230, 570, 141, 35);
        contentPane.add(btnBerechnen);
       
        //Button Abbruch - schließt das Fenster
        JButton btnAbbruch = new JButton("Abbruch");
        btnAbbruch.setBounds(230, 630, 141, 35);
        contentPane.add(btnAbbruch);
        btnAbbruch.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
                  System.exit(0);
              }
        });
       
        // Button Start startet die Animation auf der schiefen Ebene
        JButton btnStart = new JButton("Start");
        btnStart.setBounds(400, 843, 141, 35);
        contentPane.add(btnStart);
        btnStart.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent l) {
                 
              }
        });
       
        // Button Pause soll die Animation stoppen
        JButton btnPause = new JButton("Pause");
        btnPause.setBounds(580, 843, 141, 35);
        contentPane.add(btnPause);
       
        //Button Reset soll die Animation "resetten" und bei neuem beginnen
        JButton btnReset = new JButton("Reset");
        btnReset.setBounds(760, 843, 141, 35);
        contentPane.add(btnReset);
       
    }
}

Berechnungsklasse:

public class Berechnungen {
   
    //Objekte, aus denen die getters & setters konstruiert wurden
    private static double Neigungswinkel = 0.0;
    private static double Gewicht = 0.0;
    private static double Hangabtriebskraft = 0.0;
    private static double Normalkraft = 0.0;
    private static double Reibungskoeffizient = 0.0;
    private static double Reibungskraft = 0.0;  
    private static double Beschleunigungskraft = 0.0;
    private static double g = 9.81;
    private static double Gewichtskraft = 0.0;
    private static double WinkelinBogenmass = 0.0;
   
    //Alle get Klassen
    public static double getGewichtskraft() {
        return getGewicht() * getG();
    }
    public static double getWinkelinBogenmass() {
        return 2*Math.PI / 360 * getNeigungswinkel();
    }
    public static double getNeigungswinkel() {
        return Neigungswinkel;
    }
    public static double getGewicht() {
        return Gewicht;
    }
    public static double getHangabtriebskraft() {
        return getGewichtskraft() * Math.sin( getWinkelinBogenmass() );
    }
    public static double getNormalkraft() {
        return getGewichtskraft() * Math.cos( getWinkelinBogenmass() );
    }
    public static double getReibungskoeffizient() {
        return Reibungskoeffizient;
    }
    public static double getReibungskraft() {
        return getNormalkraft() * getReibungskoeffizient();
    }
    public static double getBeschleunigungskraft() {
        return getHangabtriebskraft() - getReibungskraft();
    }
    public static double getG() {
        return g;
    }
   
    //Alle set Klassen
    public static void setNeigungswinkel(double α) {
        Neigungswinkel = α;
    }
    public static void setGewicht(double m) {
        Gewicht = m;
    }
    public static void setHangabtriebskraft(double Fha) {
        Hangabtriebskraft = Fha;
    }
    public static void setNormalkraft(double Fn) {
        Normalkraft = Fn;
    }
    public static void setReibungskoeffizient(double µ) {
        Reibungskoeffizient = µ;
    }
    public static void setReibungskraft(double Fr) {
        Reibungskraft = Fr;
    }
    public static void setBeschleunigungskraft(double Fb) {
        Beschleunigungskraft = Fb;
    }
    public static void setG(double g) {
        Berechnungen.g = g;
    }
    public static void setWinkelinBogenmaß(double winkelinBogenmass) {
        WinkelinBogenmass = winkelinBogenmass;
    }
    public static void setGewichtskraft(double Fg) {
        Gewichtskraft = Fg;
    }
}

Zeichenklasse:

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JPanel;
import javax.swing.Timer;

public class zeichnen_EbeneKlotz extends JPanel implements ActionListener {
       
        //getters and setters, um die Werte von der Eingabe zu bekommen
        private static double Neigungswinkel = 45.0; //Anfangswert 45, um am Anfang eine Ebene zu haben
        private static double WinkelinBogenmass = 0.0;
   
        public static double getNeigungswinkel(double u) {
            return Neigungswinkel=u;
            }
        public static double getWinkelinBogenmass() {
            return (Math.PI / 180) * Neigungswinkel;
            }
        public static void setNeigungswinkel(double α) {
            Neigungswinkel = α;
            }
        public static void setWinkelinBogenmass(double winkelinBogenmass) {
            WinkelinBogenmass = winkelinBogenmass;
            }
       
        //Fuer die Animation
        Timer tm = new Timer(20, this); //5 gibt den sleep für 5 ms an

        double l = 700 - Math.tan(getWinkelinBogenmass()) * 250; // 700- da von oben ausgehend
       
        //Schrittweite in y-Richtung als Variable konstruieren
        int q = 1;// Schrittweite in y-Richtung ist 1 groß
       
        //Schrittweite in x-Richtung
        double j = Math.tan(Math.PI - getWinkelinBogenmass()) * 1;
        int d = (int)j;
       
        //Variablen der Höhe und Breite für die Animation konstruieren, Vel gibt die Schrittweite für die Animation an
        int n = 300 , Velb = d ;
        int m = (int)l , Velh = q;  
       
        //Grösse des Klotzes festlegen
        double f = 30; // Länge der oberen und unteren Seite des Klotzes in Pixel
        double z = 15; // Länge der rechten und linken Seite des Klotzes in Pixel
       
        double x1 =  n - Math.cos(-getWinkelinBogenmass()) * f; // Winkel negativ annehmen, da es sonst nicht geht
        double y1 =  m - Math.sin(-getWinkelinBogenmass() ) * f;
        double x22 = n + Math.sin(-getWinkelinBogenmass()) * z;
        double y22 = m - Math.cos(-getWinkelinBogenmass()) * z;
        double x11 = x22 - Math.cos(getWinkelinBogenmass()) * f;
        double y11 = y22 - Math.sin(-getWinkelinBogenmass()) * f;
           
        int v = (int)y1;
        int w = (int)x1;
        int o = (int)x11;
        int t = (int)y11;
        int u = (int)x22;
        int i = (int)y22;
               
    public void paintComponent (Graphics g) {
   
        System.out.println(j);      
       
        super.paintComponent(g);
       
        Graphics2D g2d = (Graphics2D) g;
       
        //Für bessere Konturen
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
       
        //Farbe aus schwarz festgelegt
        g.setColor(Color.BLACK);
       
        //Zeichendicke festlegen auf 5 Pixel
        ((Graphics2D) g).setStroke(new BasicStroke(5));
       
        //Ebene
       
        //Startwerte für die Ebene
        int x = 50;
        int y = 700;
        int ak = 250; //Länge der Ankatete
        int b = x + 250; //Wert rechts unten am 90 Grad Winkel
       
        //Gegenkatete ausrechnen
        double l = Math.tan(getWinkelinBogenmass()) * ak;
       
        //Umwandlung von double zu int
        int hoehe = (int)l;
        int h = 700 - hoehe; //Weil die Höhe von oben ausgehend bestimmt wird.
               
        //Befehle zum Linienzeichnen
        //Ankatete - länge 250
        g.drawLine( x , y, x + ak, y);
       
        //Gegenkatete
        g.drawLine( b , y, b , h);
       
        //Hypothenuse
        g.drawLine(x , y , b , h);
       
        //Klotz
           
        //Für bessere Konturen
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
       
        //Farbe als schwarz festgelegt
        g.setColor(Color.BLACK);
       
        //Zeichendicke festlegen auf 3 Pixel
        ((Graphics2D) g).setStroke(new BasicStroke(3));
       
        //Untere Gerade
        g.drawLine( w, v, n, m);
       
        //Obere Gerade
        g.drawLine( o, t, u, i);
       
        //Rechte Gerade
        g.drawLine( n, m, u, i);
       
        //Linke Gerade
        g.drawLine( w, v, o, t);
       
        tm.start();
    }
   
         public void actionPerformed(ActionEvent e) {
                   
            n = n + Velb;
            m = m + Velh;
            w = w + Velb;
            t = t + Velh;
            v = v + Velh;
            u = u + Velb;
            i = i + Velh;
            o = o + Velb;
            repaint();          
    }  
}

Die anderen Klassen, wie die für das infofenster lass ich jetzt mal weg, sodass das hier nicht zu viel wird.

Viele Grüße und besten Dank vorab!

Julius

 

[Xyz1]

//Objekte, aus denen die getters & setters konstruiert wurden private static double Neigungswinkel = 0.0; private static double Gewicht = 0.0; private static double Hangabtriebskraft = 0.0; private static double Normalkraft = 0.0; private static double Reibungskoeffizient = 0.0; private static double Reibungskraft = 0.0; private static double Beschleunigungskraft = 0.0; private static double g = 9.81; private static double Gewichtskraft = 0.0; private static double WinkelinBogenmass = 0.0;

und man anschließend noch einen Körper eine Ebene runter fahren/rutschen lassen kann

Wozu braucht man all diese Werte?

Du brauchst eigentlich nur einen modifizierten g Wert sowie die Ebene

 

[Julbe]

Naja ich weiß nicht, wie ich es anderst hätte machen sollen
In den Vorlesungen haben wir es auch immer so gemacht.

Wie würdest du es denn machen?

 

[Xyz1]

In welcher Vorlesung hattet ihr das? Mit AWT das zu machen ist nicht ganz einfach.

 

[Julbe]

Das Ding ist, dass wir bisher in der Vorlesung nichts mit einer Schleife animiert haben, wir es aber für das Programm brauchen...
Scheinbar machen wir das noch, jedoch muss ich bis nächsten Freitag einen groben Entwurf abgeben und da würde ich schon gerne wissen, ob und wie das funktioniert.

 

[Xyz1]

Das beantwortet meine Frage nicht. Frag vielleicht mal Deinen Prof oder Tutor.

 

[mihe7]

Wenn ich mich nicht verrechnet habe, dann sollte a = g(sin(w)-µcos(w)), also s(t) = g(sin(w)-µcos(w))*t*t/2 gelten.

Beim Start der Animation merkst Du Dir die aktuelle Zeit (System.currentTimeMillis()). Während der Animation hast Du somit t gegeben und kannst s(t) berechnen.

 

[Xyz1]

Mihe7 hat wieder die lösung des problems hergezaubert, welche ich nicht verstehe. :/

 

[mihe7]

Soweit ich das verstanden habe: Die Gewichtskraft wird in die Hangabtriebskraft und die Normalkraft aufgeteilt. Die Abtriebskraft ist parallel, die Normalkraft senkrecht zur schiefen Ebene.

Gewichtskraft: m*g
Hangabtriebskraft: Gewichtskraft * sin(w)
Normalkraft: Gewichtskraft * cos(w)
wobei w der Winkel zwischen der "horizontalen" und der schiefen Ebene ist.

Die Reibungszahl µ gibt an, wie stark die Normalkraft Berücksichtigung findet:
Reibungskraft: µ * Normalkraft

Die Reibungskraft wirkt der Abtriebskraft entgegen, d. h. die Kraft, die auf die Kiste wirkt beträgt:
Gesamtkraft: Hangabtriebskraft - Reibungskraft = m*g*sin(w) - µ*m*g*cos(w) = m*(g*sin(w) - µ*g*cos(w))

Kraft ist Masse x Beschleunigung, also m*a. Gleichgesetzt:
m*a = m*(g*sin(w) - µ*g*cos(w))
<=> a = g*sin(w) - µ*g*cos(w) = g*(sin(w) - µ*cos(w))

Wird ein Körper t Sekunden lang einer gleichförmigen Beschleunigung a ausgesetzt wird, erreicht er die Geschwindigkeit v(t) = a*t (EDIT: wenn man von Anfangsgeschwindigkeit 0 ausgeht). Die Durchschnittsgeschwindigkeit beträgt nach t Sekunden (v(t) - v(0)) / 2 = v(t) / 2 = a*t/2 für v(0) = 0 (ich gehe mal davon aus, dass die Kiste zu Beginn steht). Der mit der Durchschnittsgeschwindigkeit zurückgelegte Weg beträgt nach t Sekunden daher s(t) = a*t/2 * t = a*t*t/2. Jetzt noch a einsetzen: s(t) = g*(sin(w) - µ*cos(w))*t*t/2

 

[Xyz1]

t habe ich verstanden, nur nicht, wie man eine partielle, schiefe, dreidimensionale Ebene oder Level/Flat (welche lokal schräg beleuchtet wird) low-level ohne Funktionen dafür in Java zeichnen sollte. Angefangen beim Scanline-Algorithmus hätte ich besonders Schwierigkeiten.

 

[mihe7]

nur nicht, wie man eine partielle, schiefe, dreidimensionale Ebene oder Level/Flat (welche lokal schräg beleuchtet wird)

LOL - im Mondschein?

 

[Xyz1]

LOL - im Mondschein?

Also die Lichtquelle darf auch eine Sonne sein