programming-examples/java/Computer_Graphics/ScalingExampleColour.java
2019-11-15 12:59:38 +01:00

134 lines
4.7 KiB
Java

import java.awt.*;
import java.awt.geom.*;
/**
* Ein Rechteck wird mit dem Faktor 2 in x-Richtung gestreckt und
* dem Faktor 0.5 in y-Richtung gestaucht. Die Zeichnung wird nicht
* auf Fenster-, sondern auf reale Koordinaten bezogen.
*
* @author Frank Klawonn
* Letzte Aenderung 07.01.2005
*/
public class ScalingExampleColour extends Frame
{
private int windowHeight;
/**
* Konstruktor
*
* @param height Dieser Wert sollte die Hoehe des Fensters angeben.
*/
ScalingExampleColour(int height)
{
//Ermoeglicht das Schliessen des Fensters
addWindowListener(new MyFinishWindow());
windowHeight = height;
}
public void paint(Graphics g)
{
Graphics2D g2d = (Graphics2D) g;
/*In yUp wird die Translation definiert, mit der Objekte in "realen"
Koordinaten, bei denen die y-Achse nach oben zeigt, so in das
Fenster gezeichnet werden, dass der Koordinatenursprung sich links
unten im Fenster im Fensterkoordinatenpunkt (40,windowHeight-50)
befindet.
*/
AffineTransform yUp = new AffineTransform();
yUp.setToScale(1,-1);
AffineTransform translate = new AffineTransform();
translate.setToTranslation(40,windowHeight-50);
yUp.preConcatenate(translate);
//Wende die Transformation auf das Graphics2D-Objekt an. Damit wird
//alles in realen Koordinaten gezeichnet.
g2d.transform(yUp);
//Die Linien sollen eine Dicke von 3.0 statt 1.0 haben.
g2d.setStroke(new BasicStroke(3.0f));
//Erzeuge und zeichne ein Rechteck, das skaliert werden soll.
Rectangle2D.Double rect = new Rectangle2D.Double(80,120,100,60);
g2d.draw(rect);
//Definiere eine Skalierung.
AffineTransform scaling = new AffineTransform();
scaling.setToScale(2,0.5);
//Zeichne das skalierte Rechteck in Rot.
g2d.setPaint(Color.red);
g2d.draw(scaling.createTransformedShape(rect));
g2d.setPaint(Color.black);
g2d.setStroke(new BasicStroke(1.0f));
//Einzeichnen des Koordinatensystems
drawSimpleCoordinateSystem(540,200,g2d);
}
/**
* Zeichnet ein Koordinatensystem.
*
* @param xmax x-Koordinate, bis zu der die x-Achse reichen soll
* @param ymax y-Koordinate, bis zu der die y-Achse reichen soll
* @param g2d Graphics2D-Objekt, auf das gezeichnet werden soll.
*/
public static void drawSimpleCoordinateSystem(int xmax, int ymax,
Graphics2D g2d)
{
int xOffset = 0;
int yOffset = 0;
int step = 20;
String s;
//aktuellen Font merken
Font fo = g2d.getFont();
//einen Font einstellen
int fontSize = 13;
Font fontCoordSys = new Font("serif",Font.PLAIN,fontSize);
/*
Leider werden die Buchstaben durch die auf das Graphics2D-Objekt
angewendete Transformation auf dem Kopf gezeichnt. Daher: Erzeugung
eines Fonts, bei dem die Buchstaben auf dem Kopf stehen.
*/
//Auf den Kopf stellen durch Spiegeln.
AffineTransform flip = new AffineTransform();
flip.setToScale(1,-1);
//Wieder auf die Grundlinie zurueck verschieben.
AffineTransform lift = new AffineTransform();
lift.setToTranslation(0,fontSize);
flip.preConcatenate(lift);
//Font mit auf den Kopf gestellten Buchstaben erzeugen.
Font fontUpsideDown = fontCoordSys.deriveFont(flip);
g2d.setFont(fontUpsideDown);
//x-Achse
g2d.drawLine(xOffset,yOffset,xmax,yOffset);
//Markierungen und Beschriftung der x-Achse
for (int i=xOffset+step; i<=xmax; i=i+step)
{
g2d.drawLine(i,yOffset-2,i,yOffset+2);
g2d.drawString(String.valueOf(i),i-7,yOffset-30);
}
//y-Achse
g2d.drawLine(xOffset,yOffset,xOffset,ymax);
//Markierungen und Beschriftung der y-Achse
s=" "; //zum Einruecken der Zahlen < 100
for (int i=yOffset+step; i<=ymax; i=i+step)
{
g2d.drawLine(xOffset-2,i,xOffset+2,i);
if (i>99)
{
s="";
}
g2d.drawString(s+String.valueOf(i),xOffset-25,i-20);
}
//Font zurueck setzen
g2d.setFont(fo);
}
public static void main(String[] argv)
{
int height = 300;
ScalingExampleColour f = new ScalingExampleColour(height);
f.setTitle("Beispiel Skalierung");
f.setSize(500,height);
f.setVisible(true);
}
}