# "Dicke" einer Linie - Line2D.Double



## Student (3. Nov 2005)

Hi Leute,
ich habe die API bemüht, aber irgendwie .. nuja.

Frage:
Ist es nicht möglich einem Objekt der Klasse Line2D.Double zu sagen, dass es z.B. 5 Pixel "dick" sein soll?

Danke für die Hilfe.
Grüße Ben.


----------



## lin (3. Nov 2005)

```
setStroke(new BasicStroke(5));
```


----------



## Student (3. Nov 2005)

Danke.

Ich bin jetzt also hier
:arrow: http://java.sun.com/j2se/1.4.2/docs/api/java/awt/Graphics2D.html#setStroke(java.awt.Stroke)

Allerdings frage ich mich jetzt, wie ich das z.B. in dieser Klasse hier verwenden soll?

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

class Balken extends Line2D.Double implements Hindernis {

    public Balken(Point2D start, Point2D end) {
          super(start, end);
    }

}
```

Ich habe hier ja gar kein Graphics2D-Objekt zur Verfügung. Reicht es, wenn ich einfach ein solches im Konstruktor mit übergebe?

Grüße Ben.


----------



## Bert Brenner (4. Nov 2005)

Nimm falls du so nicht weiterkommst, nimm doch ein ausgefülltes Rechteck.


----------



## Sky (4. Nov 2005)

Wo malst Du denn deinen Balken ?

Spontan würde ich es so machen:
	
	
	
	





```
class PaintTest extends JComponent {
  protected void paintComponent( Graphics g ) {
    super.paintComponent( g );
    Graphics2D g2 = ( Graphics2D )g;
    g2.setStroke(new BasicStroke(5));
    g2.draw( new Balken( new Point2D.Double(10,10), new Point2D.Double( 100, 100 ) ) );
  }
}
```

PaintTest kannste dann auf dein Panel / Frame hinzufügen.


----------



## Student (5. Nov 2005)

Hi,
ich habe eine Klasse Balken, welche das Interface Hindernis implementiert und von der Klasse Line2D.Double erbt.

Die Klasse sieht so aus.

```
package flipper;

import java.awt.*;
import java.awt.geom.*;


class Balken extends Line2D.Double implements Hindernis {


	/**
	 * 
	 * Balken(Point2D, Point2D)
	 * 
	 * @param start
	 * @param end
	 * 
	 * Konstruktor ruft den Konstruktor der Oberklasse auf.
	 */
	public Balken(Point2D start, Point2D end) {
		super(start, end);
	}
```
Da bräuchte ich jetzt ja irgendwie ein Graphics-Objekt, um das zu machen, was ihr vorschlagt.

Ablauf ist Folgender.
Ich starte ein Applet. In der init()-Methode rufe ich die Methode initSpielfeld() auf, welche folgendermaßen aussieht.

```
/**
	 * 
	 * initSpielfeld()
	 * 
	 * Initialisierung des Spielfeldes. 
	 * Es werden hier die Hinderniselemente zusammengefügt, die im Endeffekt das Spielfeld darstellen
	 * sollen.
	 */
	private void initSpielfeld() {
		
		Hindernis balkenLinks        = new Balken(new Point(80,80), new Point(80,420));
		this.hindernisse.add(balkenLinks);
		
		Hindernis balkenRechts       = new Balken(new Point(420,80), new Point(420,420));
		this.hindernisse.add(balkenRechts);
		
		Hindernis balkenOben         = new Balken(new Point(80,80), new Point(420,80));
		this.hindernisse.add(balkenOben);
		
		Hindernis balkenUntenLinks   = new Balken(new Point(80,420), new Point(210,420));
		this.hindernisse.add(balkenUntenLinks);
		
		Hindernis balkenUntenrechts  = new Balken(new Point(290,420), new Point(420,420));
		this.hindernisse.add(balkenUntenrechts);		
	
	}
```

"hindernisse" ist in diesem Fall eine ArrayList. Das nur am Rande.

Ich zeichne den ganzen "Kram" auf ein JPanel. Ich habe jetzt schon versucht es folgendermaßen zu machen.

```
/**
	 * 
	 * initSpielfeld()
	 * 
	 * Initialisierung des Spielfeldes. 
	 * Es werden hier die Hinderniselemente zusammengefügt, die im Endeffekt das Spielfeld darstellen
	 * sollen.
	 */
	private void initSpielfeld() {
		
		Hindernis balkenLinks        = new Balken(new Point(80,80), new Point(80,420), this.zeichenflaeche.getGraphics());
		this.hindernisse.add(balkenLinks);
		
                // [...]	
	
	}
```
wobei "zeichenflaeche" das JPanel ist.

Die Klasse "Balken" habe ich dann so umgeändert:

```
package flipper;

import java.awt.*;
import java.awt.geom.*;


class Balken extends Line2D.Double implements Hindernis {


	/**
	 * 
	 * Balken(Point2D, Point2D)
	 * 
	 * @param start
	 * @param end
	 * 
	 * Konstruktor ruft den Konstruktor der Oberklasse auf.
	 */
	public Balken(Point2D start, Point2D end, Graphics g) {
		super(start, end);
		
		Graphics2D g2 = (Graphics2D) g;
		g2.setStroke(new BasicStroke(5));
	}

}
```
Allerdings hat das nicht zum gewünschten Erfolg geführt.


So wirklich wichtig ist es für mich nicht, dass die Linie zwei, drei oder fünf Pixel breit ist.
Ich kam darauf, weil ich Probleme damit hatte zu überprüfen, ob eine Koordinate (Point2D) in einem Hindernis enthalten ist.

Das Problem entsteht, weil ich überprüfen will, ob eine Kugel (extends Ellipse2D.Double) ein Hindernis berührt. Ich dachte mir, dass die Methode contains(..) dafür ganz gut sein könnte. 

Ich habe mittlerweile in der Klasse "Kugel" (extends Ellipse2D.Double implements Hindernis) folgende Methoden

```
/**
	 * 
	 * move()
	 * 
	 * Die Flipperkugel wird bewegt, indem sie an einer anderen Stelle neugezeichnet wird.
	 */
	public void move() {
		
		this.checkCollapse();
		
		double x = this.getX() + 1;
		double y = this.getY() + 1;
		
		this.setFrame(x,y,this.radius * 2, this.radius * 2);
		
	}
	

	
	/**
	 * 
	 * checkCollapse()
	 *
	 * Kleine Testmethode, die überprüft, ob die Hindernisse erkennen, ob die Kugel eine Koordinate 
	 * mit ihnen teilt oder nicht.
	 */
	private void checkCollapse() {
	    
		Iterator iter = this.hindernisse.iterator();
		
		while(iter.hasNext()) {
			Shape h = (Shape)iter.next();

			if(h.contains(this.getX(), this.getY())) {
				System.out.println("Collapse");
			}
		}	
	}
```

In der while-Schleife teste ich also mal aus, ob das mit der contains()-Methode funktioniert. 
Das ist irgendwie nicht der Fall.

Ich schreibe das jetzt in diesen Thread mal hinzu, weil ja eventuell durch die Lösung des eigentlichen Problems die Beantwortung der Sache hier mit der dickeren Linie erstmal in den Hintergrund gestellt werden kann.

Ich danke euch 

Grüße Ben.


----------



## Student (5. Nov 2005)

Boah .. sorry.
Mann. Ich hatte das Prinzip nicht verstanden. :roll:

Ich kann ja einfach bei der Ausgabe der Hindernis-Objekte mit setStroke() arbeiten. *ploink*

Jut. Das wäre geklärt. Sorry für das Doppelposting .. :roll: .. echt ma. Schlimm .

Allerdings klärt das nicht mein *eigentliches Problem*. Wäre nett, wenn da vielleicht auch noch jemand was zu sagen könnte.

Danke euch.

Grüße Ben.


----------



## André Uhres (6. Nov 2005)

Student hat gesagt.:
			
		

> Das Problem entsteht, weil ich überprüfen will, ob eine Kugel (extends Ellipse2D.Double)
> ein Hindernis berührt. Ich dachte mir, dass die Methode contains(..) dafür ganz gut sein könnte.


Versuchs mal mit der Methode *intersects(...)*


----------



## Student (6. Nov 2005)

Vielleicht bin ich auch nur blind, aber intersects() funktioniert doch nur mit Rechtecken, oder?
Ich bräuchte aber auch irgendwie eine Möglichkeit zu testen, ob die Kugel eine Rundung berührt etc.

Vielleicht hab ich auch nur falsch geschaut. Danke für weitere Hinweise.

Grüße Ben.


----------



## André Uhres (7. Nov 2005)

```
Class Ellipse2D:

intersects
public boolean intersects(double x,
                          double y,
                          double w,
                          double h)
```
Prüft ob das Innere dieser Ellipse2D (Kugel) sich mit dem Inneren 
des angegebenen rechteckigen Bereichs (Balken) überschneidet.
Funktioniert leider nicht für schräge Balken.

Für schräge Balken könnte man die Balken von java.awt.Polygon ableiten
und mit java.awt.geom.Area arbeiten:

```
Polygon balken = new Polygon(new int[]{
            0, 1, 100,  99        //x Koordinaten
        },
                new int[]{
            0, 0, 100, 100        //y Koordinaten
        }, 4);                       //Anzahl Eckpunkte
        Ellipse2D.Double kugel = new Ellipse2D.Double(60,39,30,30);

        Area kugelBereich = new Area(kugel);
        kugelBereich.intersect(new Area(balken));
        if(kugelBereich.isEmpty()){
            System.out.println("Kugel überschneidet Balken nicht.");
        }else{
            System.out.println("Kugel überschneidet Balken.");
        }
        //-->Konsolausgabe: Kugel überschneidet Balken.
        //Aber mit dieser Kugel: Ellipse2D.Double kugel = new Ellipse2D.Double(60,38,30,30);
        //ist die Konsolausgabe: Kugel überschneidet Balken nicht.
```


----------



## André Uhres (7. Nov 2005)

```
/*
 * Ueberschneidende_Formen.java
 */
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;
public class Ueberschneidende_Formen extends JFrame {
    private MyPanel panel;
    public Ueberschneidende_Formen() {
        super("Überschneidende Formen");
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setSize(250,180);
        setResizable(false);
        setLocationRelativeTo(null);
        //JComponents erzeugen:
        toolbar = new JToolBar();
        runterB = new JButton("Kugel tiefer");
        hochB = new JButton("Kugel höher");
        //Layout:
        toolbar.setFloatable(false);
        runterB.setEnabled(false);
        toolbar.add(runterB);
        toolbar.add(hochB);
        getContentPane().add(toolbar, BorderLayout.NORTH);
        panel = new MyPanel(60d,42,30d);
        add(panel);
        //Listeners:
        runterB.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                remove(panel);
                panel = new MyPanel(60d,42d,30d);
                add(panel);
                validate();
                runterB.setEnabled(false);
                hochB.setEnabled(true);
            }
        });
        hochB.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                remove(panel);
                panel = new MyPanel(60d,35d,30d);
                add(panel);
                validate();
                runterB.setEnabled(true);
                hochB.setEnabled(false);
            }
        });
    }
    public static void main(String args[]) {new Ueberschneidende_Formen().setVisible(true);}
    private JButton hochB, runterB;
    private JToolBar toolbar;
}
class MyPanel extends JPanel{
    public MyPanel(double x, double y, double w){
        this.x=x;
        this.y=y;
        this.w=w;
        this.h=w;
    }
    public void paintComponent(Graphics g){
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;
        Polygon balken = new Polygon(new int[]{
            0, 3, 103, 100        //x Koordinaten
        },
                new int[]{
            0, 0, 100, 100        //y Koordinaten
        }, 4);                       //Anzahl Eckpunkte
        Ellipse2D.Double kugel = new Ellipse2D.Double(x,y,w,h);
        g2d.draw(balken);
        g2d.draw(kugel);
        
        Area kugelBereich = new Area(kugel);
        kugelBereich.intersect(new Area(balken));
        if(kugelBereich.isEmpty()){
            g2d.drawString("Kugel überschneidet Balken nicht.",20,110);
        }else{
            g2d.drawString("Kugel überschneidet Balken.",20,110);
        }
    }
    private double x, y, w, h;
}
```


----------



## Student (7. Nov 2005)

Danke sehr. Werde ich mir anschauen, obwohl ich nicht mit Frames arbeite, es geht um ein Applet.

Aber ich schau es mir an. Vielen Dank


----------



## André Uhres (7. Nov 2005)

Das Gleiche als JApplet:

```
/*
 * Ueberschneidung.java
 */
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;
public class Ueberschneidung extends JApplet {
    public void init() {
        try {
            EventQueue.invokeAndWait(new Runnable() {
                public void run() {
                    initComponents();
                }
            });
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    private void initComponents() {
        //JComponents erzeugen:
        toolbar = new JToolBar();
        runterB = new JButton("Kugel tiefer");
        hochB = new JButton("Kugel höher");
        //Layout:
        toolbar.setFloatable(false);
        runterB.setEnabled(false);
        toolbar.add(runterB);
        toolbar.add(hochB);
        getContentPane().add(toolbar, BorderLayout.NORTH);
        panel = new MyPanel(60d,42,30d);
        add(panel);
        //Listeners:
        runterB.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                remove(panel);
                panel = new MyPanel(60d,42d,30d);
                add(panel);
                validate();
                runterB.setEnabled(false);
                hochB.setEnabled(true);
            }
        });
        hochB.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                remove(panel);
                panel = new MyPanel(60d,35d,30d);
                add(panel);
                validate();
                runterB.setEnabled(true);
                hochB.setEnabled(false);
            }
        });
    }
    private MyPanel panel;
    private JButton hochB, runterB;
    private JToolBar toolbar;
}
class MyPanel extends JPanel{
    public MyPanel(double x, double y, double w){
        this.x=x;
        this.y=y;
        this.w=w;
        this.h=w;
    }
    public void paintComponent(Graphics g){
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;
        Polygon balken = new Polygon(new int[]{
            0, 3, 103, 100        //x Koordinaten
        },
                new int[]{
            0, 0, 100, 100        //y Koordinaten
        }, 4);                       //Anzahl Eckpunkte
        Ellipse2D.Double kugel = new Ellipse2D.Double(x,y,w,h);
        g2d.draw(balken);
        g2d.draw(kugel);
        
        Area kugelBereich = new Area(kugel);
        kugelBereich.intersect(new Area(balken));
        if(kugelBereich.isEmpty()){
            g2d.drawString("Kugel überschneidet Balken nicht.",20,110);
        }else{
            g2d.drawString("Kugel überschneidet Balken.",20,110);
        }
    }
    private double x, y, w, h;
}
```


----------

