Animation einer Zahnradpumpe

[andi11]

Hallo zusammen,

ich möchte die Animation einer Zahnradpumpe in Java erstellen, genauso wie diese

https://de.wikipedia.org/wiki/Zahnradpumpe
(Animation rechts: Animation einer Außenzahnradpumpe)

Also ein festes Gehäuse, zwei Zahnräder, die ineinander greifen und sich drehen und Blasen, die durch die Pumpe laufen und die Flüssigkeit wiederspiegeln. Kann mir einer einen Tipp geben wie ich vorgehen sollte.

Ich würde vielleicht die Zahnräder über ein Polygon erstellen mit Vorgabe entsprechender Punkte. Muss ich das Gehäuse komplett aus einzelnen Strichen zeichnen oder gibt es auch eine zusammenhängende Linie? Mit welchem Begriff kann ich die Zahnräder drehen lassen. Ich würde vielleicht die Blasen nicht so geordnet durch die Pumpe laufen lassen wie in der Animation oben sondern mit einem Zufallsgenerator einbauen, der die Laufrichtung immer ein wenig verändert. Das wichtigste aber, wie sag ich den Blasen in welchen Grenzen sie sich aufhalten dürfen. Wenn ich das Zahnrad aus einem Polygon mit Vorgabe weniger Punkten besteht, kann ich mit immer nur auf diese Punkte beziehen und den Blasen einen Mindestabstand zu diesen vorgeben. Oder gibt es bessere Möglichkeiten?

 

[kneitzel]

Also ich sehe so auf Anhieb zwei Lösungen.
Die erste Lösung zeichnet alles einfach. Dazu musst Du einfach nur die Punkte definieren. Das Drehen des Zahnrades bekommst Du durch einfaches neuzeichnen - Die neuen Punkte lassen sich einfach (Ohne besonders große Mathe-Kenntnisse) berechnen. Dazu malst Du Dir das einfach einmal auf einem Zettel auf. Pack das Zahnrad am Anfang einfach mal mit Drehpunkt 0,0 - das vereinfacht es. Dann ist die Berechnung immer: Verschiebung der Punktes vom Drehpunkt hin zu 0,0, dann die Drehung und dann die Verschiebung zurück.
Die Blasen legst Du auch einfach einmal fest und drehst diese dann mit. Musst nur aufpassen, denn die Blasen drehen sich nur teilweise so mit und teilweise wandern die halt etwas anders.
Das ganze lässt sich dann auch noch sehr gut Optimieren. Wenn Du dafür sorgst, dass sich alles ständig wiederholt, dann drehst Du nur um ein oder zwei zacken und danach wiederholt sich alles immer.
Die Blasen, die nicht mitwandern dürfen, bekommen dann einfache Routen. Am einfachsten sind die immer auf einer Linie. Von der Animation her sollte dies unproblematisch sein.

Die andere Möglichkeit ist, dass Du nichts selbst zeichnest sondern fertige Bilder nimmst. Diese drehst Du dann immer etwas um einen Drehpunkt. Das kann teilweise aber recht unschön aussehen. Es gibt aber Libraries, die z.B. Kanten glätten können und so. Das würde das Bild dann wieder optimieren. Das halte ich aber für die kompliziertere Lösung - es sei denn, man hat die entsprechenden Libraries ehh zur Hand und nutzt diese dann direkt.

Hat dies etwas geholfen? Die 2D Mathematik mit Drehungen um einen fixen Punkt finden sich bestimmt auch per Google, so dies Probleme bereiten sollte.

 

[andi11]

Hallo kneitzel,

vielen Dank erstmal für die Tipps.
Die Zahnräder habe ich nun erstellt. Ich gebe jeweils den Mittelpunkt und den Drehwinkel vor. Es sieht nur noch ein bisschen eckig aus. Am schönsten wäre es die Punkte mit einem Spline zu verbinden. Wie mache ich das am einfachsten?

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import javax.swing.JOptionPane;
import javax.swing.JPanel;


public class Zeichnung extends JPanel{
  
  private int xsize=700;
  private int ysize=700;   
  private BufferedImage ImgZahnrad= new BufferedImage(xsize, ysize, BufferedImage.TYPE_INT_ARGB);
  
   public void Zahnrad (int [] Mp, double d1w)
   {
     
       int d1 = 100;
       int d2 = (int) Math.round(d1*0.95);
       int d3 = (int) Math.round(d1*0.78);
       int d4 = (int) Math.round(d1*0.66);
       
       //double d1w = 0;
       double d2w = 6;
       double d3w = 12;
       double d4w = 20;
       double d5w = 28;
       double d6w = 34;
       
       int PunktNo = 0;
       
       int[] xpoints = new int [60];
       int[] ypoints = new int [60];
       int npoints = 53;
       

       while (d1w < 350)
       {
         
         xpoints[PunktNo]=(int) (Mp[0]-d1*Math.cos(Math.PI/180*d1w));
         xpoints[PunktNo+1]=(int) (Mp[0]-d2*Math.cos(Math.PI/180*(d1w+d2w)));
         xpoints[PunktNo+2]=(int) (Mp[0]-d3*Math.cos(Math.PI/180*(d1w+d3w)));
         xpoints[PunktNo+3]=(int) (Mp[0]-d4*Math.cos(Math.PI/180*(d1w+d4w)));
         xpoints[PunktNo+4]=(int) (Mp[0]-d3*Math.cos(Math.PI/180*(d1w+d5w)));
         xpoints[PunktNo+5]=(int) (Mp[0]-d2*Math.cos(Math.PI/180*(d1w+d6w)));
       
         ypoints[PunktNo]=(int) (Mp[1]-d1*Math.sin(Math.PI/180*d1w));
         ypoints[PunktNo+1]=(int) (Mp[1]-d2*Math.sin(Math.PI/180*(d1w+d2w)));
         ypoints[PunktNo+2]=(int) (Mp[1]-d3*Math.sin(Math.PI/180*(d1w+d3w)));
         ypoints[PunktNo+3]=(int) (Mp[1]-d4*Math.sin(Math.PI/180*(d1w+d4w)));
         ypoints[PunktNo+4]=(int) (Mp[1]-d3*Math.sin(Math.PI/180*(d1w+d5w)));
         ypoints[PunktNo+5]=(int) (Mp[1]-d2*Math.sin(Math.PI/180*(d1w+d6w)));

         d1w=d1w+40;   
         PunktNo=PunktNo+6;
       }
         
       Graphics2D g2d = ImgZahnrad.createGraphics();
       g2d.setColor(Color.BLACK);
       g2d.drawPolygon(xpoints, ypoints, npoints);
       g2d.setColor(Color.GRAY);
       g2d.fillPolygon(xpoints, ypoints, npoints);
    
   }

  public void paint( Graphics g )  
   {
     //super.paint(g);
     g.drawImage(ImgZahnrad, 0, 0, null);                   

  }
}

 

[andi11]

Hallo,
nun möchte ich die Zahnräder drehen lassen.
Dazu zeichne ich jeweils die Zahnräder im vorgegebenen Drehwinkel farbig.
Die vorherige Position der Zahnräder überzeichne ich in weiss.
Das Problem ist nun, dass in der Version unten jeweils nur ein Zahnrad gezeichnet wird. Warum?

Setze ich statt:
g2d.drawImage(ImgZahnrad, 0, 0, null);

dieses:
g2d.drawImage(GlobalVar.ImgZahnrad1, 0, 0, null);
g2d.drawImage(GlobalVar.ImgZahnrad2, 0, 0, null);

werden beide Zahnräder gezeichnet, aber ein Zahnrad überdeckt immer das Andere, so dass der Bereich, in dem die Zähne ineinandergreifen überdeckt ist.

package p1;

import java.awt.image.BufferedImage;

public class GlobalVar {
   
   public static int [] Mp1 = {390,300};
   public static int xsize1=700;
   public static int ysize1=700;   
   public static int npoints1 = 53;
   public static int[] xpoints1 = new int [60];
   public static int[] ypoints1 = new int [60];
   public static BufferedImage ImgZahnrad1= new BufferedImage(xsize1, ysize1, BufferedImage.TYPE_INT_ARGB);
   
   public static int [] Mp2 = {220,300};
   public static int xsize2=700;
   public static int ysize2=700;
   public static int npoints2 = 53;
   public static int[] xpoints2 = new int [60];
   public static int[] ypoints2 = new int [60];
   public static BufferedImage ImgZahnrad2= new BufferedImage(xsize2, ysize2, BufferedImage.TYPE_INT_ARGB);
}

--------------------------------------------------

package p1;  

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Graph extends JApplet implements ActionListener, AdjustmentListener
{

   private final Timer timer = new Timer(50, null);   //Timer
   
   JPanel MainPanel = new JPanel();   
   JPanel scrollPanel=new JPanel();
   Zeichnung Zeichnung = new Zeichnung();
   ZeichnungDel ZeichnungDel = new ZeichnungDel();
  JButton start = new JButton("Start");
  JButton stop = new JButton("Stop");
  Scrollbar speed = new Scrollbar(Scrollbar.VERTICAL,10,2,1,10);
   
  int No=1;
  int Drehrichtung=0;
  double d1w = 0;
     
  public void init()
  {
       setSize(800,800);               //Fenstergröße
       
       MainPanel.setLayout(null);           //Hauptpanel erstellen
       getContentPane().add(MainPanel);       //Hinzufügend des Panels zu Content Plane
       MainPanel.setBounds(0, 0, 800, 800);     //Größe und Lage des Panels setzen
       Zeichnung.setLayout(null);   
       MainPanel.add(Zeichnung);

       MainPanel.add(scrollPanel);
       MainPanel.add(start);
       MainPanel.add(stop);
       
      scrollPanel.setLayout(new BorderLayout());
      scrollPanel.add("North",new Label("  schnell  "));
      scrollPanel.add("Center", speed);
      scrollPanel.add("South", new Label("  langsam  "));
      scrollPanel.add("East", new Label("  "));
      scrollPanel.add("West", new Label("  "));       

      scrollPanel.setBounds(680, 250, 100, 500);
      start.setBounds(50, 700, 120, 40);
      stop.setBounds(200, 700, 120, 40);
      Zeichnung.setBounds(0, 0, 700, 700);
       
       setVisible(true);               //Applet sichtbar machen
         
      speed.addAdjustmentListener(this);
      start.addActionListener(this);
      stop.addActionListener(this);
      timer.addActionListener(this);
      
  }
   
  public void actionPerformed(ActionEvent e)
  {
   
  if (e.getSource() == start) {
     timer.start();
  }
   
  if (e.getSource() == stop) {
     
       timer.stop();
  }
     
     
  if (e.getSource() == timer)
     {

     ZeichnungDel.Zahnrad(1);
     ZeichnungDel.Zahnrad(2);
     
     No=1;
     Drehrichtung=1;
      Zeichnung.Zahnrad(No, d1w*Drehrichtung);
       
      No=2;
      Drehrichtung=-1;
      Zeichnung.Zahnrad(No, d1w*Drehrichtung);
       
      d1w=d1w+1;
     }
   }
}

-----------------------------------------------------------

package p1;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import javax.swing.JOptionPane;
import javax.swing.JPanel;


public class Zeichnung extends JPanel{


   int d1 = 100;
   int d2 = (int) Math.round(d1*0.95);
   int d3 = (int) Math.round(d1*0.78);
   int d4 = (int) Math.round(d1*0.66);

   double d1w_save = 0;
   double d2w = 6;
   double d3w = 12;
   double d4w = 20;
   double d5w = 28;
   double d6w = 34;
   
   int[] Mp;
   int npoints;
   int[] xpoints;
   int[] ypoints;
   BufferedImage ImgZahnrad;
   
   
   public void Zahnrad (int No, double d1w)
   {
             
       if (No==1)
       {
         Mp=GlobalVar.Mp1;
         npoints = GlobalVar.npoints1;
         xpoints = GlobalVar.xpoints1;
         ypoints = GlobalVar.ypoints1;
         ImgZahnrad=GlobalVar.ImgZahnrad1;         
         
       }
       
       if (No==2)
       {
         Mp=GlobalVar.Mp2;
         npoints = GlobalVar.npoints2;
         xpoints = GlobalVar.xpoints2;
         ypoints = GlobalVar.ypoints2;
         ImgZahnrad=GlobalVar.ImgZahnrad2;
       }
       

       int PunktNo = 0;
       d1w_save=d1w;
       
       
       while (d1w < 350+d1w_save)
       {
         
         xpoints[PunktNo]=(int) (Mp[0]+d1*Math.cos(Math.PI/180*d1w));
         xpoints[PunktNo+1]=(int) (Mp[0]+d2*Math.cos(Math.PI/180*(d1w+d2w)));
         xpoints[PunktNo+2]=(int) (Mp[0]+d3*Math.cos(Math.PI/180*(d1w+d3w)));
         xpoints[PunktNo+3]=(int) (Mp[0]+d4*Math.cos(Math.PI/180*(d1w+d4w)));
         xpoints[PunktNo+4]=(int) (Mp[0]+d3*Math.cos(Math.PI/180*(d1w+d5w)));
         xpoints[PunktNo+5]=(int) (Mp[0]+d2*Math.cos(Math.PI/180*(d1w+d6w)));
       
         ypoints[PunktNo]=(int) (Mp[1]+d1*Math.sin(Math.PI/180*d1w));
         ypoints[PunktNo+1]=(int) (Mp[1]+d2*Math.sin(Math.PI/180*(d1w+d2w)));
         ypoints[PunktNo+2]=(int) (Mp[1]+d3*Math.sin(Math.PI/180*(d1w+d3w)));
         ypoints[PunktNo+3]=(int) (Mp[1]+d4*Math.sin(Math.PI/180*(d1w+d4w)));
         ypoints[PunktNo+4]=(int) (Mp[1]+d3*Math.sin(Math.PI/180*(d1w+d5w)));
         ypoints[PunktNo+5]=(int) (Mp[1]+d2*Math.sin(Math.PI/180*(d1w+d6w)));

         d1w=d1w+40;   
         PunktNo=PunktNo+6;
       }
   
       Graphics2D g2d = ImgZahnrad.createGraphics();
       g2d.setColor(Color.BLACK);
       g2d.drawPolygon(xpoints, ypoints, npoints);
       g2d.setColor(Color.GRAY);
       g2d.fillPolygon(xpoints, ypoints, npoints);
       this.repaint();
           
       //Rückgabe der "globalen" Objekte
       if (No==1)
       {
         GlobalVar.xpoints1 = xpoints;
         GlobalVar.ypoints1 = ypoints;
         GlobalVar.ImgZahnrad1 = ImgZahnrad;            
       }
       
       if (No==2)
       {

         GlobalVar.xpoints2 = xpoints;
         GlobalVar.ypoints2 = ypoints;
         GlobalVar.ImgZahnrad2 = ImgZahnrad;
       }        
   }

   
   
  public void paintComponent( Graphics g )    //Zeichnen
   {
     super.paintComponent(g);
     
     Graphics2D g2d = (Graphics2D) g;
     g2d.drawImage(ImgZahnrad, 0, 0, null);   
     //g2d.drawImage(GlobalVar.ImgZahnrad1, 0, 0, null);   
     //g2d.drawImage(GlobalVar.ImgZahnrad2, 0, 0, null);  
  }
}

-----------------------------------------------------------------------------

package p1;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import javax.swing.JOptionPane;
import javax.swing.JPanel;


public class ZeichnungDel extends JPanel{

   int npoints;
   int[] xpoints;
   int[] ypoints;
   BufferedImage ImgZahnrad;
   
   
   public void Zahnrad (int No)
   {
             
       //Abruf der "globalen" Objekte
       if (No==1)
       {
         npoints = GlobalVar.npoints1;
         xpoints = GlobalVar.xpoints1;
         ypoints = GlobalVar.ypoints1;
         ImgZahnrad=GlobalVar.ImgZahnrad1;         
         
       }
       
       if (No==2)
       {
         npoints = GlobalVar.npoints2;
         xpoints = GlobalVar.xpoints2;
         ypoints = GlobalVar.ypoints2;
         ImgZahnrad=GlobalVar.ImgZahnrad2;
       }

       
       Graphics2D g2d = ImgZahnrad.createGraphics();
       g2d.setColor(Color.WHITE);
       g2d.drawPolygon(xpoints, ypoints, npoints);
       g2d.setColor(Color.WHITE);
       g2d.fillPolygon(xpoints, ypoints, npoints);
       this.repaint();
       
       //Rückgabe der "globalen" Objekte
       /*
       if (No==1)
       {
         GlobalVar.ImgZahnrad1 = ImgZahnrad;         
       }
       
       if (No==2)
       {
         GlobalVar.ImgZahnrad2 = ImgZahnrad;
       }
*/         
   }

   
  public void paintComponent( Graphics g )    //Zeichnen
   {
     super.paintComponent(g);
     
     Graphics2D g2d = (Graphics2D) g;
     g2d.drawImage(ImgZahnrad, 0, 0, null);   
     //g2d.drawImage(GlobalVar.ImgZahnrad1, 0, 0, null);   
     //g2d.drawImage(GlobalVar.ImgZahnrad2, 0, 0, null);
     
  }
}

 

[Jardcore]

Bist du auf eine bestimmte Java Version beschränkt?

Mit JavaFX z.B geht das relativ einfach.
1. Du kannst dort entweder ein Bild nehmen und dieses rotieren.
2. Oder eine Svg Grafik erstellen und diese rotieren.

Dann musst du nicht mit den ganzen Math Methoden rumhantieren.
Das sieht dann eher so aus.

Erstelle Leinwand. (Pane*1 oder Canvas)
Erstelle Zahnrad.
Füge Zahnrad zur Leinwand hinzu.
Drehe Zahnrad.

*1: Pane ist ein Container den man mit Objekten füllen kann. In diesem Fall svg GrafikObjekte.

https://docs.oracle.com/javase/8/javafx/api/javafx/application/Application.html
http://www.java2s.com/Code/Java/JavaFX/RotateImageView.htm
https://docs.oracle.com/javase/8/javafx/api/javafx/scene/shape/SVGPath.html

 

[andi11]

Wenn JavaFX mit dem Internet Explorer in der Regel funktioniert, ist das in Ordnung, denke ich.
Nur wie erkenne ich nachher das Zahnrad, damit die Blasen nicht mit den Zähnen kollidieren.

 

[andi11]

Hallo zusammen,

Ich habe die Zahnradpumpe nun soweit fertig, dass sich die Zahnräder drehen.
Nun möchte ich die Blasen modellieren.

Ich möchte eine beliebige Anzahl an Luftblasen erzeugen, die durch die Zahnradpumpe laufen. Dabei erscheinen zufallsmäßig neue Blasen an unterschiedlichen Positionen am Eingang der Zahnradpumpe. Sie laufen dabei parallel zu einer Leitlinie bis sie am Zahnrad ankommen sind. Weiter bin ich noch nicht gekommen.

Leider gibt es Probleme beim Zeichnen. Ich schreibe die Positionen aller Blasen in ein Array. Dieses wird dann in ein BufferedImage übertragen. Dabei wird das Image mit allen Blasen immer wieder neu gezeichnet, wobei die alten Positionen sichtbar bleiben. Habe schon verschiedenes versucht, z.B. ein weiteres BufferedImage eingefügt, in dem ich die alten Positionen speichere und dann weiß überschreibe. Aber das funktioniert auch nicht.

(siehe folgenden Programmausschnitt)

public class Bubbles
{
     
   //----------------------------------------------------
   //Parameter anderer Klassen übernehmen
   
   int r1 = Zeichnung.r1;
   int bOeffnung=Zeichnung.bOeffnung;
   

   //----------------------------------------------------------------
   // Parameter für Leitlinien
   int rEin = (Zeichnung.r1-Zeichnung.r9)/2+15;
   int LaengeArray=13;
   int alpha=0;
   int alphadelta=10;
   int xMitte=GlobalVar.Mp1[0]+GlobalVar.Achsabstand/2;
   int yMitte=GlobalVar.Mp1[1];
   
   int[][] Linie1 = new int[LaengeArray][2];
   int[][] Linie2 = new int[LaengeArray][2];
   int[][] Linie3 = new int[LaengeArray][2];
   int[][] Linie4 = new int[LaengeArray][2];
   
   public static BufferedImage ImgLinie1= new BufferedImage(GlobalVar.xsize1, GlobalVar.ysize1, BufferedImage.TYPE_INT_ARGB);
   int[] xpkt1 = new int [LaengeArray];
   int[] ypkt1 = new int [LaengeArray];
   
   public static BufferedImage ImgLinie2= new BufferedImage(GlobalVar.xsize1, GlobalVar.ysize1, BufferedImage.TYPE_INT_ARGB);
   int[] xpkt2 = new int [LaengeArray];
   int[] ypkt2 = new int [LaengeArray];
   
   public static BufferedImage ImgLinie3= new BufferedImage(GlobalVar.xsize1, GlobalVar.ysize1, BufferedImage.TYPE_INT_ARGB);
   int[] xpkt3 = new int [LaengeArray];
   int[] ypkt3 = new int [LaengeArray];
   
   public static BufferedImage ImgLinie4= new BufferedImage(GlobalVar.xsize1, GlobalVar.ysize1, BufferedImage.TYPE_INT_ARGB);
   int[] xpkt4 = new int [LaengeArray];
   int[] ypkt4 = new int [LaengeArray];
   
   
   //----------------------------------------------------------------
   // Parameter für Bubbles
   int MinGroesseBub=5;
   int MaxGroesseBub=25;
   
   public static int [][] BubbleArray = new int [10][3];
   public static BufferedImage ImgBubbles= new BufferedImage(GlobalVar.xsize1, GlobalVar.xsize1, BufferedImage.TYPE_INT_ARGB);
   
   public static int [][] BubbleArrayVorh = new int[10][3];
   public static BufferedImage ImgBubblesVorh= new BufferedImage(GlobalVar.xsize1, GlobalVar.xsize1, BufferedImage.TYPE_INT_ARGB);

   Color BubblesColor = new Color(138,208,218);

   int DistanzZ1;
   int DistanzZ2;
   
   int AbstandLinie1=0;
   int AbstandMin=1000;    //muss auf einen hohen Wert gesetzt werden
   int PosMinAbstand=0;
   double Bewegungwinkel=0;
   double Abschnittslaenge=0;
   
   double GeschwBasis=0;
   double rm = Zeichnung.r1-Zeichnung.r9;
   double aktGeschwBzglD=0;
   double aktGeschwBzglL=0;
   double aktGeschwBzgl=0;
   
   double lLBasis= Math.round(rEin*Math.PI/180*alphadelta); //Länge der letzten 2 Punkte der Leitlinie

   
   public void BubblesBewegen()
   {
     Graphics2D g2d1 = ImgBubbles.createGraphics();
     Graphics2D g2d2 = ImgBubblesVorh.createGraphics();
     
     if (BubbleArray[0][0]==0)
     {
       return;
     }
     
     // Berechnung Geschwindigkeit für die Mitte des Zahnrades, Bewegung des Punktes immerhalb des Zeitintervalls
     GeschwBasis= Zeichnung.r1 * Math.PI/180*GlobalVar.DrehwinkelDelta;  //Pixel pro Timerzeit
     
     //Berechnung des nächsten Punktes eines jeden Bubbles
     for(int k=0; k < BubbleArray.length; k++)
     {
       
       if (BubbleArray[k][0]>0)
       {
       
         DistanzZ1=(int) Math.sqrt(Math.pow((BubbleArray[k][0]-GlobalVar.Mp1[0]),2)+Math.pow((BubbleArray[k][1]-GlobalVar.Mp1[1]),2));
         DistanzZ2=(int) Math.sqrt(Math.pow((BubbleArray[k][0]-GlobalVar.Mp2[0]),2)+Math.pow((BubbleArray[k][1]-GlobalVar.Mp2[1]),2));   
             
         if (BubbleArray[k][0] <= xMitte && BubbleArray[k][1] <= yMitte && DistanzZ1 > Zeichnung.r1+BubbleArray[k][2])
         {
           
           for(int i=0; i < Linie1.length; i++)
           {
             // Abstand zur Leitlinie wird ermittelt und Position des minimlalen Abstands festgehalten
             AbstandLinie1=(int) Math.round(Math.sqrt(Math.pow((BubbleArray[k][0]-Linie1[i][0]),2)+Math.pow((BubbleArray[k][1]-Linie1[i][1]),2)));
             
             if    (BubbleArray[k][0] > Linie1[i][0])
             {
               AbstandLinie1=AbstandLinie1*-1;  //wird benötigt für spätere Geschwindigkeitsberechnung, Geschwindigkeit entsprechend Durchmesser
             }
             
             if (Math.abs(AbstandLinie1) <= Math.abs(AbstandMin))
             {
               PosMinAbstand=i;
               AbstandMin=AbstandLinie1;
             }
             else
             {
               //break;
             }

           }
           
           //Ermittlung des Winkels der Leitlinie
           Bewegungwinkel = Math.tan((Linie1[PosMinAbstand][0]-Linie1[PosMinAbstand+1][0])/(Linie1[PosMinAbstand+1][1]-Linie1[PosMinAbstand][1]));   
           Abschnittslaenge = Math.sqrt(Math.pow((Linie1[PosMinAbstand][0]-Linie1[PosMinAbstand+1][0]),2)+Math.pow((Linie1[PosMinAbstand+1][1]-Linie1[PosMinAbstand][1]),2));   
           
           
           //Berechnung der neuen Position       
           aktGeschwBzglD = GeschwBasis/rm*(rm+AbstandMin);
           aktGeschwBzglL = aktGeschwBzglD*lLBasis/Abschnittslaenge;
           BubbleArray[k][0]=BubbleArray[k][0]+(int) Math.round(aktGeschwBzglL*Math.sin(Math.PI/180*Bewegungwinkel));
           BubbleArray[k][1]=BubbleArray[k][1]+(int) Math.round(aktGeschwBzglL*Math.cos(Math.PI/180*Bewegungwinkel));
           
           g2d2.setColor(Color.WHITE);
           g2d2.drawOval(BubbleArrayVorh[k][0],BubbleArrayVorh[k][1],BubbleArrayVorh[k][2],BubbleArrayVorh[k][2]);
           g2d2.setColor(Color.WHITE);
           g2d2.fillOval(BubbleArrayVorh[k][0],BubbleArrayVorh[k][1],BubbleArrayVorh[k][2],BubbleArrayVorh[k][2]);
           
           g2d1.setColor(Color.BLACK);
           g2d1.drawOval(BubbleArray[k][0],BubbleArray[k][1],BubbleArray[k][2],BubbleArray[k][2]);
           g2d1.setColor(BubblesColor);
           g2d1.fillOval(BubbleArray[k][0],BubbleArray[k][1],BubbleArray[k][2],BubbleArray[k][2]);
           
           BubbleArrayVorh = BubbleArray;

         }
       }
       AbstandMin=1000;
     }
   }
     

   public void BubblesErstellen()
   {
     // Bubble erzeugen und in Array ablegen
     // x, y-Koordinate, Größe des Bubble
     for (int i=0; i <BubbleArray.length; i++)
     {
       
       if (BubbleArray [i][0] == 0)
       {
         BubbleArray [i][2]=(int) Math.round(MinGroesseBub +Math.random()*(MaxGroesseBub-MinGroesseBub));     // Größe Bubble
         BubbleArray [i][1]=Linie1[0][1];                                     // Stratpos. y        
         BubbleArray [i][0]=(int) Math.round(xMitte-bOeffnung/2+BubbleArray[i][2] + Math.random()*(bOeffnung-2*BubbleArray[i][2]));   // Startpos. x

         break;
       }       
     }
     
     //alle Bubbles in Image zeichnen
     Graphics2D g2d = ImgBubbles.createGraphics();

     for(int m=0; m < BubbleArray.length; m++)
     {
       g2d.setColor(Color.BLACK);
       g2d.drawOval(BubbleArray[m][0],BubbleArray[m][1],BubbleArray[m][2],BubbleArray[m][2]);
       g2d.setColor(BubblesColor);
       g2d.fillOval(BubbleArray[m][0],BubbleArray[m][1],BubbleArray[m][2],BubbleArray[m][2]);
     }     
   }
     
   public void LeitlinienErstellen()
   {
     
     //Erstellung Linie links oben
     Linie1[0][0] = GlobalVar.Mp1[0]+GlobalVar.Achsabstand/2-bOeffnung/4;
     Linie1[0][1] = GlobalVar.Mp1[1]-Zeichnung.r1-50;
     Linie1[1][0] = Linie1[0][0];
     Linie1[1][1] = Linie1[0][1]+35;
     Linie1[2][0] = Linie1[0][0];
     Linie1[2][1] = GlobalVar.Mp1[1]-Zeichnung.r1;
     
     for (int i=3; i<LaengeArray; i++)
     {
       Linie1[i][0] = (int) (Linie1[2][0]-rEin+rEin*Math.cos(Math.PI/180*alpha));   
       Linie1[i][1] = (int) (Linie1[2][1]+rEin*Math.sin(Math.PI/180*alpha));
       alpha += alphadelta;
     }     
     
     //Erstellung Linie rechts oben
     for (int i=0; i<LaengeArray; i++)
     {
       Linie2[i][0] = Linie1[i][0]+2*(xMitte-Linie1[i][0]);
       Linie2[i][1] = Linie1[i][1];
     }   
     
     //Erstellung Linie links unten
     for (int i=0; i<LaengeArray; i++)
     {
       Linie3[i][0] = Linie1[i][0];
       Linie3[i][1] = Linie1[i][1]+2*(yMitte-Linie1[i][1]);
     }   
     
     //Erstellung Linie rechts unten
     for (int i=0; i<LaengeArray; i++)
     {
       Linie4[i][0] = Linie3[i][0]+2*(xMitte-Linie3[i][0]);
       Linie4[i][1] = Linie3[i][1];
     }   
     

     //----------------------------------------------------------------------
     //Linien zeichnen (zur Kontrolle
     for (int m=0; m <= Linie1.length-1; m++)
     {
       xpkt1[m] = Linie1[m][0];
       ypkt1[m] = Linie1[m][1];
     }
     
     for (int m=0; m <= Linie2.length-1; m++)
     {
       xpkt2[m] = Linie2[m][0];
       ypkt2[m] = Linie2[m][1];
     }

     for (int m=0; m <= Linie3.length-1; m++)
     {
       xpkt3[m] = Linie3[m][0];
       ypkt3[m] = Linie3[m][1];
     }
     
     for (int m=0; m <= Linie4.length-1; m++)
     {
       xpkt4[m] = Linie4[m][0];
       ypkt4[m] = Linie4[m][1];
     }
     
     Graphics2D g2d1 = ImgLinie1.createGraphics();
     g2d1.setColor(Color.BLACK);
     g2d1.drawPolyline(xpkt1, ypkt1, 12);

     Graphics2D g2d2 = ImgLinie2.createGraphics();
     g2d2.setColor(Color.BLACK);
     g2d2.drawPolyline(xpkt2, ypkt2, 12);
     
     
     Graphics2D g2d3 = ImgLinie3.createGraphics();
     g2d3.setColor(Color.BLACK);
     g2d3.drawPolyline(xpkt3, ypkt3, 12);
     
     Graphics2D g2d4 = ImgLinie4.createGraphics();
     g2d4.setColor(Color.BLACK);
     g2d4.drawPolyline(xpkt4, ypkt4, 12);    
   }
}

-------------------------------------------------------



public class Zeichnung extends JPanel{
....
....
....
   

  public void paintComponent( Graphics g )    //Zeichnen
   {
     super.paintComponent(g);
     Graphics2D g2d = (Graphics2D) g;

     g2d.drawImage(ImgGeh, 0 ,0 , null);
     
     g2d.drawImage(Bubbles.ImgLinie1, 0 ,0 , null);
     g2d.drawImage(Bubbles.ImgLinie2, 0 ,0 , null);
     g2d.drawImage(Bubbles.ImgLinie3, 0 ,0 , null);
     g2d.drawImage(Bubbles.ImgLinie4, 0 ,0 , null);   
     
     g2d.drawImage(Bubbles.ImgBubblesVorh, 0 ,0 , null);
     g2d.drawImage(Bubbles.ImgBubbles, 0 ,0 , null);   

     AffineTransform at1 = new AffineTransform();
   AffineTransform at2 = new AffineTransform();

   at1.rotate(Math.toRadians(-GlobalVar.Drehwinkel*GlobalVar.Drehrichtung),GlobalVar.Mp1[0],GlobalVar.Mp1[1]);
   at2.rotate(Math.toRadians(GlobalVar.Drehwinkel*GlobalVar.Drehrichtung),GlobalVar.Mp2[0],GlobalVar.Mp2[1]);
     
   g2d.drawImage(GlobalVar.ImgZahnrad1, at1, null);
   g2d.drawImage(GlobalVar.ImgZahnrad2, at2, null);   

  }   
}