# Seitenlänge aus einem Würfel lesen



## KimWangLee (4. Feb 2008)

Ich beschäftige mich seit einigen Wochen mit Java3D und habe jetzt vor die Seite a eines Würfels auf ein Textfeld auszugeben. 

Also wenn man auf den Button "OK" klickt wird auf dem Textfeld die Seite a des Würfels ausgegeben, damit das nicht langweilig wird möchte ich noch den Würfel mit der Maus vergrößern und verkleiner. 

Nach tagelangem suchen in diverse Foren fand ich die Picking-Klasse. Ich benutzte PickZoomBehavior-Klasse um den Würfel zu verkleinern, stellte aber fest, dass das Objekt nur herand bzw. weg gezoomt wird.

hier der Code:

```
import java.applet.Applet;
import java.awt.*;
import java.awt.GraphicsConfiguration;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.universe.SimpleUniverse;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.behaviors.mouse.MouseRotate;
import javax.media.j3d.*;
import java.awt.event.*;


public class MySimpleUniverse extends Applet implements ActionListener
{


   // Inhaltszweig
   public BranchGroup erzeugeInhalt()
   {
      // Erzeugen einer (Wurzel)Gruppe die den geamten Inhalt des Universum aufnehmen soll
      BranchGroup inhalt = new BranchGroup();

      // Erzeugen eines geometrischen Objektes inklusive voreingestellten Aussehens
      ColorCube farbigerWuerfel = new ColorCube(0.4);
      
      // Erzeugen einer Transformgruppe mit Zugriffsrechten fuer Maussteuerung
      TransformGroup tg = new TransformGroup();
      tg.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
      tg.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

      // Gebe dem verwaisten Wuerfel drehfreudige Eltern
      tg.addChild(farbigerWuerfel);

      // Erzeuge ein Mausdrehobjekt in einem geplanten Bereich mit Ziel-Transformgruppe
      MouseRotate rotor = new MouseRotate();
      rotor.setSchedulingBounds(new BoundingSphere());
      rotor.setTransformGroup(tg);

      // Einhaengen der Transformgruppe und des Mausverhaltens in die Wurzelgruppe
      inhalt.addChild(tg);
      inhalt.addChild(rotor);

      // Optimiert den gesamten Inhaltszweig - nicht unbedingt erforderlich
      inhalt.compile();

      return inhalt; // Los, gibs mir!
   }

   // Sichtzweig
   public SimpleUniverse erzeugeSicht()
   {
      // Erzeugen eines minimalen virtuellen Universums mit Hilfe der SimpleUniverse-Klasse
      SimpleUniverse minimalesUniversum = null;

      // Besorgen der besten Konfiguration hinsichtlich der
      // Anzeigeumgebung (Farbtiefe, Tranzparenzwerte der Pixel, ...)
      GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();

      // Erzeugen des aeusserst schweren Anzeigeflaeche-Objektes
      Canvas3D canvas3d = new Canvas3D(config);
      canvas3d.setBounds(100,0,300,300);
      // Hinzufügen der Anzeigeflaeche zum Clientbereich des Fensters
      add(canvas3d);

      // Uebergabe des Canvas3D-Objekts als Anzeigeflaeche
      minimalesUniversum = new SimpleUniverse(canvas3d);

      // setNominalViewingTransform() stellt den Betrachter 2,41m auf die positive
      // z-Achse mit Sichtrichtung nach unten in negative z-Achse
      minimalesUniversum.getViewingPlatform().setNominalViewingTransform();

      return minimalesUniversum; // Her mit dem Mist!
   }

   // Diese Methode wird vom Browser beim Laden des Applets aufgerufen.
   public void init()
   {
      // Erzeuge neues Layout für Container
      setLayout(null);
      
      // Erzeuge eines Buttons
      Button b = new Button("OK");
      b.setBounds(1,50,40,30);
      b.addActionListener(this);
      
      // Erzeuge eines Textfelds
      TextField t = new TextField();
      t.setBounds(2,10,50,30);

      // Erzeuge eines Panels
      Panel p = new Panel();
      p.setBounds(0,0,100,300);
      p.setLayout(null);
      p.add(t);
      p.add(b);
      this.add(p);

      // Sei Gott und erzeuge ein minimales Universum mit Sicht auf den Inhalt
      SimpleUniverse su = erzeugeSicht();

      // Sei Gott und erzeuge den Inhalt des Universums mit Maussteuerung
      BranchGroup suInhalt = erzeugeInhalt();

      // Es werde Licht! - verbindet Universum inklusive Sicht mit Inhalt
      su.addBranchGraph(suInhalt);
   }
   
   public void actionPerformed(ActionEvent evt){

   }
   

   // Startpunkt fuer die Laufzeitumgebung
   public static void main(String[] args)
   {
      new MainFrame(new MySimpleUniverse(), 800, 600);
   }
}
```


Ich hoffe jemand kann mir helfen.


----------



## susa. (6. Feb 2008)

hey,
also du legst die Größe ja im Konstruktor fest. Ich hab jetzt keine Funktion gefunden, mit der du skalieren kannst. Dass das mit dem PickZoom nicht größer/kleiner macht ist auch klar. Der Name "Zoom" sagt doch alles. Aber ich denke mit Zoom kannst du auch fast alles machen... vllt etwas umständlicher, aber so wie ich das bisher sehe, gehts nicht anderes. aber vllt meldet sich ja noch jemand, der mehr erfahrung hat....
lg


----------



## kimwanglee (11. Feb 2008)

habe ein neues Programm geschrieben, wenn man im Textfeld eine Zahl eingibt und auf den Button drückt wird ein Würfel gezeichnet. Jetzt möchte ich diesen verkleinern und die SeiteA soll dabei automatisch aktuellisiert werden, weis aber noch nicht wie.

hier der code

```
import java.awt.event.*;
import javax.media.j3d.*;
import javax.swing.*;
import com.sun.j3d.utils.behaviors.mouse.MouseRotate;
import com.sun.j3d.utils.behaviors.picking.*;
import com.sun.j3d.utils.geometry.Cylinder;
import com.sun.j3d.utils.universe.SimpleUniverse;
import java.awt.*;


public class MainProg implements ActionListener{

//erzeuge einen Frame
private JFrame f = new JFrame();
//In den Frame kommt ein JPanel
private JPanel p = new JPanel();
//und auch ein Canvas3D
private Canvas3D canvas;
//ins Panel kommen ein Textfeld, ein Label und ein Button
private JTextField SeiteA = new JTextField();
private JLabel labelSeiteA = new JLabel("Seite a");
private JButton b = new JButton("OK");

private SimpleUniverse universe = null;
private BranchGroup objRoot = new BranchGroup();
private BranchGroup bg = new BranchGroup();
private TransformGroup tg = new TransformGroup();
private BoundingSphere behaveBounds = new BoundingSphere();

//nach der Main kommt die Klasse ObjekteZeichnen
ObjekteZeichnen oz = new ObjekteZeichnen();


public MainProg() {
   f.setSize(630, 500);
   f.setLocation(100, 100);
   f.setTitle("MainProg");
   f.setLayout(null);
   
   GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
   canvas = new Canvas3D( config );
   canvas.setBounds(130, 0, 500, 500);
   
   universe = new SimpleUniverse( canvas );
   universe.getViewingPlatform().setNominalViewingTransform();
   
   tg.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
   tg.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
   tg.setCapability(TransformGroup.ENABLE_PICK_REPORTING);
   
   objRoot.setCapability(BranchGroup.ALLOW_CHILDREN_WRITE);
   objRoot.setCapability(BranchGroup.ALLOW_CHILDREN_READ);
   objRoot.setCapability(BranchGroup.ALLOW_CHILDREN_EXTEND);
   
   p.setSize(130, 500);
   p.setLayout(null);
   
   SeiteA.setBounds(5,40,80,30);
   labelSeiteA.setBounds(5,15,80,30);
   b.setBounds(15,80,60,30);
   b.addActionListener(this);
   
   p.add(SeiteA);
   p.add(labelSeiteA);
   p.add(b);
   
   f.add(p);
   f.add(canvas);
   f.setResizable(false);
   f.setVisible(true);
  }
  
  
  public void actionPerformed(ActionEvent evt){
  if(evt.getSource()==b){
  try{
    Shape3D shape = new Shape3D( oz.WürfelZeichnen(SeiteA.getText()));

    BranchGroup bg = new BranchGroup();
    bg.setCapability(BranchGroup.ALLOW_DETACH);
    
    PickZoomBehavior pickZoom = new PickZoomBehavior(objRoot, canvas, behaveBounds);
    
    MouseRotate rotor = new MouseRotate();
    rotor.setSchedulingBounds(new BoundingSphere());
    rotor.setTransformGroup(tg);

    tg.addChild( shape );
    bg.addChild( tg );

    bg.addChild( rotor );
    bg.addChild(pickZoom);
    objRoot.addChild(bg);
    objRoot.compile();
    universe.addBranchGraph(objRoot);
    }catch(RestrictedAccessException e){

  }
  }
  }
  
  public static void main(String[] args) {
  new MainProg();
  }
  
}



class ObjekteZeichnen{

  public Geometry WürfelZeichnen(String seite_a) {
    QuadArray qa = new QuadArray(24, QuadArray.COORDINATES | QuadArray.COLOR_3);

    Float a;
    a = Float.valueOf(seite_a);
    final float[] punkte = {

            // Vorderseite
             a/2, -a/2,  a/2,
             a/2,  a/2,  a/2,
            -a/2,  a/2,  a/2,
            -a/2, -a/2,  a/2,
            // Rückseite
            -a/2, -a/2, -a/2,
            -a/2,  a/2, -a/2,
             a/2,  a/2, -a/2,
             a/2, -a/2, -a/2,
            // Rechteseite
             a/2, -a/2, -a/2,
             a/2,  a/2, -a/2,
             a/2,  a/2,  a/2,
             a/2, -a/2,  a/2,
            // Linkeseite
            -a/2, -a/2,  a/2,
            -a/2,  a/2,  a/2,
            -a/2,  a/2, -a/2,
            -a/2, -a/2, -a/2,
            // Oben
             a/2,  a/2,  a/2,
             a/2,  a/2, -a/2,
            -a/2,  a/2, -a/2,
            -a/2,  a/2,  a/2,
            // Unten
            -a/2, -a/2,  a/2,
            -a/2, -a/2, -a/2,
             a/2, -a/2, -a/2,
             a/2, -a/2,  a/2,
        };

        final float[] farbe = {
            // Vorderseite
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            // Rückseite
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            // Rechteseite
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            // Linkeseite
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            // Oben
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            // Unten
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
        };
        qa.setCoordinates(0, punkte);
        qa.setColors(0, farbe);
      return qa;
  }
  }
```
[/code]


----------



## Marco13 (11. Feb 2008)

Hmja, ist jetzt nicht sooo klar, was du machen willst. Aber im Moment wird jedes mal, wenn du eine Eingabe machst, ein NEUER Würfel mit der gewünschten Größe angelegt. Wenn du durch draggen der Maus einen Skalierungsfaktor einstellen willst, mit dem der würfel Sakliert wird, und der ZUSÄTZLICH im TextField angezeigt wird, dann könntest du eine Tansform3D erstellen, die den (Einheits-)Würfel auf die Größe 'a' skliert, und diesen Skalierungsfaktor dann entweder mit einem MouseListener oder mit einer MouseBehavior veränderbar machen (und eben in das TextField schreiben)


----------

