# Grafik durch "klick" drehen



## Marcl (17. Aug 2010)

Hallo,

habe ein Programm geschrieben, was eine Zeichnung ausgibt.
Der innere Teil soll durch betätigen eines Buttons um einen beliebig festgelegten Winkel (z.B.30°) gedreht werden.

Hat jemand eine Idee wie ich an das Problem rangehen kann.

Mein Programm sieht wie folgt aus

```
import java.applet.*;
	import java.awt.*;
	import java.awt.geom.AffineTransform;
import java.math.*;

import javax.swing.JButton;
	public class asynchron extends Applet {

		int width, height;

		   public void init() {
		      width = getSize().width;
		      height = getSize().height;
		      setBackground( Color.white );
		   }
		   
		  public void parameter (){
			   

//Einführung aller Parameter und Zuweisung zu einem Buchstaben (Verkürzung Quellcode)			   
		
//		beta_Te_R = a;     			Rotor pole arc [°]
//		double a = 17.5;
			  
//		beta_Te_S = b;				Stator pole arc [°]
//		double b = 15.5;
			  
//		c_Lam_R = g;				Lamination factor of rotor [-]
//		double g = 0.97;
				
//		c_Lam_S = d;				Lamination factor of Stator [-]
//		double d = 0.97;
				
//		c_Win = e;					Cooper slot fill factor [-]
//		double e = 0.5;
				
//		delta_Gap = f;				Air gap length [m]
//		double f = 0.0003;
				
//		h_Win = g;					Height of the stator winding [m] 
//		double g = 0.02;	
				
//		l_Stk = h;					Stack length of the machine [m]
//		double h = 0.125;

//		N_P_R = i;					Number of rotor poles [-]
//		int i = 8;
			  
//		N_P_S = j;					Number of stator poles [-]
//		int j = 12;
			  
//		N_Ph = k;					Number of phases [-]
//		int k = 3;
				
//		N_Tp = l;					Number of windings [-]
//		int l = 10;
				
//		r_0 = m;					Radius from axis to bottom of rotor slot [m]
//		double m = 0.027;
				
//		r_1 = n;					Radius from axis to surface of rotor [m]
//		double n = 0.03395;
				
//		r_2 = o;					Radius from axis to inside of stator slot [m]
//		double o = 0.0555;			  
			  
//		r_3 = p;					Radius from axis to outside stator surface [m]
//      double p = 0.06725;
						
//		r_4 = q;					Radius from axis to outside frame surface [m]
//		double q = 0.073;
			  
//		r_Sh = r;					Radius from axis to surface of shaft [m]
//		double r = 0.012;
				
//		r_Win = s;					Radius from one winding [m]
//		double s = 0.001504;
				
//		w_Can_R = t;				Width of the rotor can [m]
//		double t = 0.0003;
				
//		w_Can_S = u;				Width of the stator can [m]
//		double u = 0.0003;
				
//		w_S1_Can_S = v;				Width of stator slot to stator can [m]
//		double v = 0.0023;
				
//		w_Win = w;					Width of the winding [m]
//		double w = 0.004;
			
		  }

		
// Einführung der Drehfunktion (Math.toRadians (0)) hier 0°, um später nur mit dem 
// Befehl aft = new AffineTransform() eine neue Drehfunktion einzuführen
		 public void paint (Graphics g){
		
	  		  Graphics2D g2d = (Graphics2D) g;
			  AffineTransform aft = new AffineTransform();
			  aft.rotate(Math.toRadians(0), 400, 350);
			  g2d.setTransform(aft);
			   
//Der äußere graue Kreis wird im Maßstab 1m = 4000 Pixel gezeichnet
			  
//			  r_3 = p;								Radius from axis to outside stator surface [m]
			  double p = 0.06725;
						
//			  r_4 = q;								Radius from axis to outside frame surface [m]
			  double q = 0.073;
						
			  
			  g.setColor(Color.gray);
			  g.fillOval((int)(400-4000*q), (int) (350-4000*q),(int)(2*4000*q), (int)(2*4000*q));
			  g.setColor(Color.white);
			  g.fillOval((int)(400-4000*p), (int)(350-4000*p),(int)(2*4000*p),(int)(2*4000*p));
 
// Spaltrohre werden gezeichnet
//			    r_1 = n;					Radius from axis to surface of rotor [m]
				double n = 0.03395;
				
//				w_Can_R = t;				Width of the rotor can [m]
				double t = 0.0003;
						
//				w_Can_S = u;				Width of the stator can [m]
				double u = 0.0003;

//				delta_Gap = f;				//Air gap length [m]
				double f = 0.0003;
				
//für Stator
			  double r_stator_innen = n+t+u+f;
			  
			  g.setColor(Color.gray);
			  g.fillOval((int)(400-4000*(r_stator_innen)), (int) (350-4000*(r_stator_innen)),(int)(2*4000*(r_stator_innen)), (int)(2*4000*(r_stator_innen)));
			  g.setColor(Color.white);
			  g.fillOval((int)(400-4000*((r_stator_innen)-u)), (int) (350-4000*((r_stator_innen)-u)),(int)(2*4000*((r_stator_innen)-u)), (int)(2*4000*((r_stator_innen)-u)));
				
//für Rotor				
			  g.setColor(Color.gray);
			  g.fillOval((int)(400-4000*n), (int) (350-4000*n),(int)(2*4000*n), (int)(2*4000*n));
			  g.setColor(Color.white);
			  g.fillOval((int)(400-4000*(n-t)), (int) (350-4000*(n-t)),(int)(2*4000*(n-t)), (int)(2*4000*(n-t)));

			  
// Der Stator mit seinen Statorzähnen wird gezeichnet			  

//			    r_2 = o;					Radius from axis to inside of stator slot [m]
			   double o = 0.0555;
			  g.setColor(Color.black);
			  g.drawOval((int)(400-4000*o), (int) (350-4000*o),(int)(2*4000*o), (int)(2*4000*o));
			  
//			  N_P_S = j;					Number of stator poles [-]

			  aft = new AffineTransform();
			  int j = 3; 
			    for (int x=0; x<j; x++) 
			    { 
			    double stator = (360 / j) * x;
			    aft.rotate(Math.toRadians(stator), 400, 350);
			    g2d.setTransform(aft);
			
// Zeichnet die Wicklung um die Statorzähne		  

//				beta_Te_S = b;				Stator pole arc [°]
				double b = 15.5;
	
//				w_Win = w;					Width of the winding [m]
				double w = 0.004;
//				h_Win = c;					Height of the stator winding [m] 
				double c = 0.02;
			
			  g.setColor(Color.black);
			  g.drawRect((int)((400-((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen))-(int)(4000*w)), (int)(350-4000*o), (int)(4000*w), (int)(4000*c));
				  
			  g.setColor(Color.black);
			  g.drawRect((int)(400+((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen)), (int)(350-4000*o), (int)(4000*w), (int)(4000*c));
				  
			  g.setColor(Color.black);
			  g.drawOval((int)((400-((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen))-(int)(4000*w)), (int)(350-4000*o), 10, 10);
				 
			  g.setColor(Color.black);
			  g.fillOval((int)(400+((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen)), (int)(350-4000*o), 10, 10);
				 		  
				  
//Statorzähne werden gezeichnet	
			  g.setColor(Color.black);
			  g.drawRect((int)(400-((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen)), (int)(350-4000*o), (int)(2*((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen)), (int)(4000*(o-r_stator_innen)));
			 
			  g.setColor(Color.white);
			  g.fillRect((int)(400-((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen))+1, (int)(350-4000*o)-5, (int)(2*((Math.sin (b* 3.1415/180.0))*4000*r_stator_innen))-2, (int)(4000*(o-r_stator_innen)));
				 
		  
// Der Rotor mit seinen Rotorzähnen wird gezeichnet			  
			  
//			  N_P_R = i;					Number of rotor poles [-]
			  
//			  r_1 = n;					Radius from axis to surface of rotor [m]
//			  double n = 0.03395;		
			  
//			  r_0 = m;					Radius from axis to bottom of rotor slot [m]
			  double m = 0.027;
				
			  g.setColor(Color.black);
			  g.drawOval((int)(400-(4000*m)), (int) (350-4000*m),(int)(2*4000*m), (int)(2*4000*m));			
			  aft = new AffineTransform();
			  int i = 5; 
			    for (int y=0; y<i; y++) 
			    { 
			    double rotor = (360 / i) * y;
			    aft.rotate(Math.toRadians(rotor), 400, 350);
			    g2d.setTransform(aft);

//				beta_Te_R = a;				Rotor pole arc [°]
				double a = 17.5;		
				
			  g.setColor(Color.black);
			  g.drawRect((int)(400-((Math.sin (a* 3.1415/180.0))*4000*n)), (int)(350-4000*n), (int)(2*((Math.sin (a* 3.1415/180.0))*4000*n)), (int)(4000*(n-m)+10));
				 
			  g.setColor(Color.white);
			  g.fillRect((int)(400-((Math.sin (a* 3.1415/180.0))*4000*n)+1), (int)(350-4000*n)+1, (int)(2*((Math.sin (a* 3.1415/180.0))*4000*n))-2, (int)(4000*(n-m))+5);
			  
			  g.setColor(Color.white);
			  g.fillOval((int)(400-(4000*m)+1), (int) (350-4000*m)+1,(int)(2*4000*m)-1, (int)(2*4000*m)-1);		  

// einfügen der Drehfunktion, da sonst die letzten Kreise unnötig kopiert und gedreht werden
			  
			  aft = new AffineTransform();
			  aft.rotate(Math.toRadians(0), 400, 350);
			  g2d.setTransform(aft);
			  
			  
// Der innere graue Kreis wird gezeichnet
//				r_Sh = r;					Radius from axis to surface of shaft [m]
           		double r = 0.012;
			  g.setColor(Color.gray);
			  g.fillOval((int)(400-(4000*r)), (int) (350-4000*r),(int)(2*4000*r), (int)(2*4000*r)); 
		
   
	}
			    }
		   }
		  }
```

Der Teil ab Zeile 193 ist der sich drehen soll.
Wäre auch schon hilfreich, wenn es eine Funktion gibt, die alle 5 Sekunden oder so um einen Winkel dreht.

Danke schonma vorab.
Tschau Marcel


----------



## André Uhres (17. Aug 2010)

Du kannst den Drehwinkel z.B. in einer Instanzvariablen "angle" speichern. 
Dann brauchst du nur noch diesen Wert zur Variablen "rotor" hinzuzufügen:
double rotor = (360 / i) * y + angle;

Ein Animationsvorgang muss in einem eigenen Thread geschehen. Eine einfache Möglichkeit, diesen Thread zu verwirklichen, besteht darin, einen "javax.swing.Timer" zu benutzen.

Wenn der Winkel ändert rufst du jeweils "repaint()" auf.


----------



## Marcl (19. Aug 2010)

Hallo, hab leider immer noch eein kleines Problem mit meinem Programm.

Es ist etwas überschaubarer geworden.

Sieht jetz wie folgt aus:

```
import java.applet.*;
	import java.awt.*;
	import java.awt.geom.AffineTransform;



	public class asynchron extends Applet {

		int width, height;

		   public void init() {
		      width = getSize().width;
		      height = getSize().height;
		      setBackground( Color.white );
		   }

		   public void paint (Graphics g){

// Festlegen des Mittelpunktes (M_x, M_y) der Zeichnung und den Maßstab mit 1[m]=MST
			   
		int M_x 			= 400;				//X-Wert des Mittelpunktes der Zeichnung
		
		int M_y 			= 350;				//Y-Wert der Mittelpunktes der Zeichnung
				  
		int MST 			= 4500;				//Wert des Maßstabes 1m = MST (Anzahl der Pixel)
	
	
// Umrechnung Bogenmaß in Grad
		
		double UF = 3.1415/180;
		
//Einführung aller veränderlichen Parameter			   
		
		double beta_R 			= 17.5;				// Rotor pole arc [°]
		
		double beta_S 			= 15.5;				// Stator pole arc [°]
		
		double delta_Gap 		= 0.0003;			// Air gap length [m]			
 
		double h_Win 			= 0.02;				// Height of the stator winding [m]
				
//		l_Stk = h;					Stack length of the machine [m]
//		double h = 0.125;

		int N_P_R 			= 8;				// Number of rotor poles [-]
			  
		int N_P_S 			= 12;				// Number of stator poles [-]

		double r_0 			= 0.027;			// Radius from axis to bottom of rotor slot [m]
				
		double r_1 			= 0.03395;			// Radius from axis to surface of rotor [m]
				
		double r_2 			= 0.0555;			// Radius from axis to inside of stator slot [m]	  
			  
		double r_3 			= 0.06725;			// Radius from axis to outside stator surface [m]
						
		double r_4 			= 0.073;			// Radius from axis to outside frame surface [m]
			  
		double r_Sh			= 0.012;			// Radius from axis to surface of shaft [m]
				
		double w_Can_R			= 0.0003;			// Width of the rotor can [m]
				
		double w_Can_S			= 0.0003;			// Width of the stator can [m]
				
		double w_Win			= 0.004;			// Width of the winding [m]
		
		
// Die Polwinkel werden direkt von in Bogenmaß umgerechnet 
		
		double beta_R1			= beta_R * (UF);
		double beta_S1			= beta_S * (UF);
		
		
// Einführung der Drehfunktion (Math.toRadians (0)) hier 0°, um später nur mit dem 
// Befehl aft = new AffineTransform() eine neue Drehfunktion einzuführen
			 
	  		  Graphics2D g2d = (Graphics2D) g;
			  AffineTransform aft = new AffineTransform();
			  aft.rotate(Math.toRadians(0), M_x, M_y);
			  g2d.setTransform(aft);
	
			  
//Das Gehäuse bis zum Stator wird als Kreisabschnitt gezeichnet
		  
			  g.setColor(Color.gray);
			  g.fillOval((int)(M_x-MST*(r_4)), (int) (M_y-MST*(r_4)),(int)(2*MST*(r_4)), (int)(2*MST*(r_4)));
			  g.setColor(Color.white);
			  g.fillOval((int)(M_x-MST*(r_3)), (int)(M_y-MST*(r_3)),(int)(2*MST*(r_3)),(int)(2*MST*(r_3)));
 
			  
// Spaltrohre werden gezeichnet
			 	
		//für Stator
			  
			  // Berechnung des Stator Innenradius
			  double r_stator_innen = r_1 + w_Can_R + w_Can_S + delta_Gap;
			  
			  g.setColor(Color.gray);
			  g.fillOval((int)(M_x-MST*(r_stator_innen)), (int) (M_y-MST*(r_stator_innen)),(int)(2*MST*(r_stator_innen)), (int)(2*MST*(r_stator_innen)));
			  
			  g.setColor(Color.white);
			  g.fillOval((int)(M_x-MST*((r_stator_innen)-(w_Can_S))), (int) (M_y-MST*((r_stator_innen)-(w_Can_S))),(int)(2*MST*((r_stator_innen)-(w_Can_S))), (int)(2*MST*((r_stator_innen)-(w_Can_S))));
				
			  
		//für Rotor
			  
			  g.setColor(Color.gray);
			  g.fillOval((int)(M_x-MST*(r_1)), (int) (M_y-MST*(r_1)),(int)(2*MST*(r_1)), (int)(2*MST*(r_1)));
			  
			  g.setColor(Color.white);
			  g.fillOval((int)(M_x-MST*((r_1)-(w_Can_R))), (int) (M_y-MST*((r_1)-(w_Can_R))),(int)(2*MST*((r_1)-(w_Can_R))), (int)(2*MST*((r_1)-(w_Can_R))));

			  
// Die Innenseite des Stators wird durch einen Kreis angedeutet			  
			   
			  g.setColor(Color.black);
			  g.drawOval((int)(M_x-MST*(r_2)), (int) (M_y-MST*(r_2)),(int)(2*MST*(r_2)), (int)(2*MST*(r_2)));
			  
			  
		// Mit dem Befehl new AffineTransform wird ein neuer Abschnitt der Zeichnung festgelegt.
		// Nur auf diesen Abschnitt wird mit aft.rotate (Math.toRadians(stator), M_x, M_y) 
		// eine Drehung um den Mittelpunkt im Winkel (360°/N_P_S) vollführt.
		// x dient hierbei als Laufvariable
			  
			  aft = new AffineTransform();
			  (N_P_S) = 12; 
			    for (int x=0; x<(N_P_S); x++) 
			    { 
			    double stator = (360 / (N_P_S)) * x;
			    aft.rotate(Math.toRadians(stator), M_x, M_y);
			    g2d.setTransform(aft);
			
			    
// Zeichnet die Höhe und Breite der Wicklungen als Rechteck an die Statorzähne		  
			
			  g.setColor(Color.black);
			  g.drawRect((int)((M_x-((Math.sin ((beta_S1)/2))*MST*(r_stator_innen)))-(int)(MST*w_Win)), (int)(M_y-MST*(r_2)), (int)(MST*w_Win), (int)(MST*h_Win));
				  
			  g.setColor(Color.black);
			  g.drawRect((int)(M_x+((Math.sin ((beta_S1)/2))*MST*(r_stator_innen))), (int)(M_y-MST*(r_2)), (int)(MST*w_Win), (int)(MST*h_Win));
	
			  
// Zeichnet eine Wicklung der Statorzähne als Kreis zur besser Veranschaulichung
			  
			  g.setColor(Color.black);
			  g.drawOval((int)((M_x-((Math.sin ((beta_S1)/2))*MST*(r_stator_innen)))-10), (int)(M_y-MST*(r_2)), 10, 10);
				 
			  g.setColor(Color.black);
			  g.fillOval((int)(M_x+((Math.sin ((beta_S1)/2))*MST*(r_stator_innen))), (int)(M_y-MST*(r_2)), 10, 10);
				 		  
				  
// Die Statorzähne werden als Rechtecke gezeichnet
			  
			  g.setColor(Color.black);
			  g.drawRect((int)(M_x-((Math.sin ((beta_S1)/2))*MST*(r_stator_innen))), (int)(M_y-MST*(r_2)), (int)(2*((Math.sin ((beta_S1)/2))*MST*(r_stator_innen))), (int)(MST*((r_2)-(r_stator_innen))));
			 
			  g.setColor(Color.white);
			  g.fillRect((int)(M_x-((Math.sin ((beta_S1)/2))*MST*(r_stator_innen)))+1, (int)(M_y-MST*(r_2))-5, (int)(2*((Math.sin ((beta_S1)/2))*MST*(r_stator_innen)))-2, (int)(MST*((r_2)-(r_stator_innen))));
				 	
			  
// Die Innenseite des Rotors wird durch einen Kreis angedeutet			  
				
			  g.setColor(Color.black);
			  g.drawOval((int)(M_x-(MST*(r_0))), (int) (M_y-MST*(r_0)),(int)(2*MST*(r_0)), (int)(2*MST*(r_0)));
	
			  
		// Wieder neuen Abschnitt einführen, um den Mittelpunkt rotieren lassen und 360° durch die N_P_R teilen
		// y dient hierbei als Laufvariable
			  
			  aft = new AffineTransform();
			  (N_P_R) = 8; 
			    for (int y=0; y<(N_P_R); y++) 
			    { 
			    double rotor = (360 / (N_P_R)) * y;
			    aft.rotate(Math.toRadians(rotor), M_x, M_y);
			    g2d.setTransform(aft);

			    
// Die Rotorzähne werden als Rechteck gezeichnet.
// Die 2 Funktionen mit der Farbe white dienen zur Beseitigung überstehender Linien
			    
			  g.setColor(Color.black);
			  g.drawRect((int)(M_x-((Math.sin ((beta_R1)/2))*MST*(r_1))), (int)(M_y-((Math.cos((beta_R1)/2))*MST*(r_1))), (int)(2*((Math.sin ((beta_R1)/2))*MST*(r_1))), (int)(MST*((r_1)-(r_0))+10));
				 
			  g.setColor(Color.white);
			  g.fillRect((int)(M_x-((Math.sin ((beta_R1)/2))*MST*(r_1))+1), (int)(M_y-MST*Math.cos(((beta_R1)/2)*(r_1))+1), (int)(2*((Math.sin ((beta_R1)/2))*MST*(r_1)))-2, (int)(MST*((r_1)-(r_0)))+15);
			  
			  g.setColor(Color.white);
			  g.fillOval((int)(M_x-(MST*(r_0))+1), (int) (M_y-MST*(r_0))+1,(int)(2*MST*(r_0))-2, (int)(2*MST*(r_0))-2);		  

				  
// einfügen der Drehfunktion um den Winkel 0°, damit wieder ein neuer Abschnitt beginnt 
// und die Welle nicht unnötig mit kopiert und gedreht wird
			  
			  aft = new AffineTransform();
			  aft.rotate(Math.toRadians(0), M_x, M_y);
			  g2d.setTransform(aft);
			  
			  
// Die Welle wird gezeichnet
			       		
			  g.setColor(Color.gray);
			  g.fillOval((int)(M_x-(MST*(r_Sh))), (int) (M_y-MST*(r_Sh)),(int)(2*MST*(r_Sh)), (int)(2*MST*(r_Sh))); 
		
			  
// Hohlwelle wird gezeichnet

			  double r_Sh_innen = 0.0;
			  
			  g.setColor(Color.white);
			  g.fillOval((int)(M_x-(MST*(r_Sh_innen))), (int) (M_y-(MST*(r_Sh_innen))),(int)(2*(MST*(r_Sh_innen))), (int)(2*(MST*(r_Sh_innen))));
	
			    }
			    }
			    }
}
```

Hab immer noch das Problem, dass ich die Zeilen 171-191 alle 3 Sekunden um 30° gedreht haben möchte. Dies kann automatisch, wenn das Applet geöffnet wird oder nur klick auf einen Button.

Hat da jemand bitte eine gute Idee. Bin auch leider nicht der Hellste im Programmieren;(

danke Marcel


----------



## Michael... (20. Aug 2010)

Zunächst mal würde die Umrechnungen mit dem Maßstab direkt bei der Initialisierung der Variablen machen und nicht jedes Mal wenn ich die Werte benötige.
Dann würde ich die ganzen Berechnungen die unabhängig vom Schleifenindex sind, vor der Schleife durchführen. Das sind - soweit ich das gesehen habe - alle bis auf 
	
	
	
	





```
double stator = (360 / (N_P_S)) * x;
```
.
Das alles würde den Code schon mal ein bisschen übersichtlicher und schneller machen.

Zum Thema Rotieren: Wenn man die einzelnen in Teile zerlegt, z.B. in Methoden auslagert oder sogar eigenständige Objekte, lässt sich das meiner Meinung nach einfacher umsetzen. Das Rotieren lässt sich mittels Thread umsetzen.

Bsp:

```
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import javax.swing.JApplet;
import javax.swing.JPanel;

public class MotorApplet extends JApplet {
	private MotorPanel motorPanel;
	
	public void init() {
		motorPanel = new MotorPanel(new Stator(), new Rotor());
		this.getContentPane().add(motorPanel);
		new Thread(new Runnable() {
			private int angle = 0;
			public void run() {
				while(true) {
					try {
						Thread.sleep(100);
						angle += 10;
						motorPanel.setRotorAngle(angle);
						motorPanel.repaint();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
	}
	
	class MotorPanel extends JPanel {
		private Stator stator;
		private Rotor rotor;
		private double angle;
		
		public MotorPanel(Stator stator, Rotor rotor) {
			this.stator = stator;
			this.rotor = rotor;
			angle = 0;
			this.setBackground(Color.WHITE);
		}
		
		public void setRotorAngle(int degree) {
			this.angle = Math.toRadians(degree);
		}
		
		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			int dia = Math.min(this.getWidth(), this.getHeight())-30;
			
			Graphics2D g2 = (Graphics2D)g.create();
			g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
			g2.setStroke(new BasicStroke(5));
			g2.translate(15, 15);
			stator.paint(g2, dia);
			dia -= 120;
			g2.translate(60, 60);
			g2.rotate(angle, dia/2, dia/2);
			g2.setColor(Color.BLUE);
			rotor.paint(g2, dia);
		}
	}
	
	class Stator {
		public void paint(Graphics2D g, int dia) {
			g.drawOval(0, 0, dia, dia);
			int step = 360/8;
			for(int i=0; i<8; i++) {
				g.rotate(Math.toRadians(step), dia/2, dia/2);
				g.drawLine(20, 20, 50, 50);
			}
		}
	}
	
	class Rotor {
		public void paint(Graphics2D g, int dia) {
			g.drawRect(0, 0, dia, dia);
			g.rotate(Math.toRadians(45), dia/2, dia/2);
			g.drawRect(0, 0, dia, dia);
		}
	}
}
```


----------

