//This file is part of SECONDO.

//Copyright (C) 2004, University in Hagen, Department of Computer Science,
//Database Systems for New Applications.

//SECONDO is free software; you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation; either version 2 of the License, or
//(at your option) any later version.

//SECONDO is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.

//You should have received a copy of the GNU General Public License
//along with SECONDO; if not, write to the Free Software
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

package viewer.spatial3D;

import gui.SecondoObject;
import sj.lang.*;
import tools.Reporter;
import viewer.Spatial3DViewer;

import java.awt.Color;
import java.util.Iterator;
import java.util.Vector;

import javax.media.j3d.*;
import javax.swing.JColorChooser;
import javax.vecmath.Color3f;
import javax.vecmath.Matrix3f;
import javax.vecmath.Matrix4f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3f;

import com.sun.j3d.utils.geometry.GeometryInfo;
import com.sun.j3d.utils.geometry.NormalGenerator;

/**
 * This Class represents a object which is shown in the
 * Spatial3DViewer
 */
public class ObjectGroup {

  // Mouse options
  private CustomPickZoom pickZoom = null;
  private CustomPickMouseWheelZoom wheelZoom = null;
  private CustomPickTranslate pickTranslate = null;
  private CustomPickRotate pickRotate = null;
  private RelationPicking relationPicking = null;

  private boolean isSinglePoint;
  private boolean isRelation;
  private boolean isVaryingColorViewSelected;
  private int currentTupleLength;
  private boolean drawGrid;
  private boolean isUndefined;
  private boolean isEmpty;

  private double scaleFactor = 0.05;
  private double zoomFactor = 1;
  private double translateFactor = 0.1;
  private double rotateFactor = 0.03;
  private boolean autoScaleFactor = true;
  private float pointSize = 5.0f;
  private float singlePointSize;

  private SecondoObject secondoObject;
  private ListExpr currentType;
  private ListExpr currentObjectList;
  private Shape3D currentShape;
  private String currentTypeString;
  private Spatial3DViewer viewer;

  private Background background;
  private Canvas3D canvas;
  private BranchGroup rootScene;
  private TransformGroup objectTransGrp;
  private TransformGroup scaleTransGrp;
  private TransformGroup translateTransGrp;
  
  private Point3d standardCenterTFG = new Point3d();
  private double standardRadTFG;
  
  
  /** textViewItems saves each elements(shapes and non shapes) and cut lines */
  private Vector<String> textViewItems = new Vector<String>();
  /** shapeVector saves each elements, if it is a non shape the value is null */
  private Vector<Vector<Shape3D>> shapeVector = new Vector<Vector<Shape3D>>();
  /** objectNameVector saves the names of all shapes */
  private Vector<String> objectNameVector = new Vector<String>();
  /** objectAppearanceVector saves all Appearances from the Shapes */
  private Vector<Appearance> objectAppearanceVector = new Vector<Appearance>();
  /** transform group vector for all transformgroups */
  private Vector <TransformGroup> tfgVector = new Vector<TransformGroup>();

  // Colors
  /* standard Background color is white */
  private static final Color3f DEFAULT_BACKGROUND_COLOR = new Color3f(1.0f,
  1.0f, 1.0f);
  /* standard Grid color is black */
  private static final Color3f DEFAULT_GRID_COLOR = new Color3f(0.0f, 0.0f,
  0.0f);
  /* standard Object color is grey */
  private static final Color3f DEFAULT_OBJECT_COLOR = new Color3f(0.23f,
  0.248f, 0.243f);
  private Color3f backgroundColor = new Color3f(1.0f, 1.0f, 1.0f);
  private Color3f gridColor = new Color3f(0.0f, 0.0f, 0.0f);
  private Color3f objectColor = new Color3f(0.23f, 0.248f, 0.243f);
  private Color firstSelCol;
  private Color secSelCol;
  
  // lighting
  private LightPanel lightingPanel;
  private BranchGroup lights;
  private BranchGroup ambLightBg;
  private AmbientLight ambLight;
  private Color3f lastColor;
  
  /**
   * Constructor 
   * create the 3D object from the given SecondoObject which is shown
   * in Spatial3DViewer
   * 
   * @param o   SecondoObject
   * @param c   Canvas3D
   * @param v   Spatial3DViewer
   */
  public ObjectGroup(SecondoObject o, Canvas3D c, Spatial3DViewer v) {
    secondoObject = o;
    canvas = c;
    viewer =v;
    if (secondoObject !=null) {
      // get list and type
      currentObjectList = secondoObject.toListExpr();
      currentType = currentObjectList.first();
      if (!currentType.isAtom()) {
        currentType = currentType.first();                    // type is a relation
        }
      currentTypeString = currentType.symbolValue();

      // create rootScene and Transformgroup
      rootScene = new BranchGroup();
      rootScene.setCapability(BranchGroup.ALLOW_DETACH);

      objectTransGrp = new TransformGroup();
      objectTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
      objectTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
      objectTransGrp.setCapability(TransformGroup.ENABLE_PICK_REPORTING);

      scaleTransGrp = new TransformGroup();
      scaleTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
      scaleTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);

      translateTransGrp = new TransformGroup();
      translateTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
      translateTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);

      // Initializes vectors
      shapeVector.clear();
      textViewItems.clear();
      objectNameVector.clear();
      objectAppearanceVector.clear();
      tfgVector.clear();

      // create Appearance
      Appearance app = createAppearance();

      // create Object
      switch (currentTypeString) {
        // point3d
        case "point3d":
        case "vector3d":
        isSinglePoint = true;
        currentShape = createPoint(app, currentObjectList.second());
          break;
        case "pointcloud":
        currentShape = createPoints(app, currentObjectList.second().rest());
        break;
        // surface3d volume3d
        case "surface3d":
        case "volume3d":
        	
        currentShape = createVolume(app, currentObjectList.second());
          break;

        // relation
        case "rel":
        case "trel":
        case "mrel":
        isRelation = true;
        createRelationObjects(currentObjectList);
          break;
        
        default:return;
       }

      if (!isRelation) {                                    // it is a single object
        objectTransGrp.addChild(currentShape);
        objectNameVector.add(new String(currentTypeString.toString()));
        objectAppearanceVector.add(app);
        objectTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        objectTransGrp.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        tfgVector.add(objectTransGrp);
      }
      
      // set lighting
      lightingPanel = new LightPanel(viewer);
      viewer.addLightingPanel(lightingPanel);

      lights = new BranchGroup();
      lights.setCapability(BranchGroup.ALLOW_DETACH);
      lights.setCapability(Group.ALLOW_CHILDREN_READ);
      lights.setCapability(Group.ALLOW_CHILDREN_WRITE);
      lights.setCapability(Group.ALLOW_CHILDREN_EXTEND);
      lastColor = new Color3f(1.0f, 1.0f, 1.0f);

      // set up ambient light
      ambLight = new AmbientLight();
      BoundingSphere ambBounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), Double.MAX_VALUE);
      ambLight.setInfluencingBounds(ambBounds);
      ambLight.setEnable(true);
      ambLight.setCapability(Light.ALLOW_COLOR_READ);
      ambLight.setCapability(Light.ALLOW_COLOR_WRITE);
      ambLight.setCapability(Light.ALLOW_STATE_READ);
      ambLight.setCapability(Light.ALLOW_STATE_WRITE);
      ambLightBg = new BranchGroup();
      ambLightBg.setCapability(BranchGroup.ALLOW_DETACH);
      ambLightBg.addChild(ambLight);

      //set View
      updateView(addMouseBehavior(calcBounds(objectTransGrp)));
      
      //set Satandard TFG values
      Bounds tfgBounds = translateTransGrp.getBounds();
      BoundingSphere tfgSphere = new BoundingSphere(tfgBounds);
      tfgSphere.getCenter(standardCenterTFG);
      standardRadTFG = tfgSphere.getRadius();

   }
  }   // end constructor

  /**
   * showObjectGroup This method shows the created Objects on the 3D View. It
   * where called if the objects where already created.
   * 
   * @return root TransformGroup which contain the 3d Object(s)
   */
  public BranchGroup showObjectGroup() {
     return rootScene;
    }

  /**
   * createPoint 
   * creates a point with a given Appearance
   * 
   * @param app Appearance
   * @param value List Expression
   * @return the created Point as a Shape
   */
  private Shape3D createPoint(Appearance app, ListExpr value) {

    //check if Object is defined
    if (value.listLength()<0){
      isUndefined=true;
      return null;
    } 
    
    //check if Object is emty
    if ((value.listLength()==0)) {
      isEmpty=true;
      return null;
    }
      
    float x = (float) value.first().realValue();
    float y = (float) value.second().realValue();
    float z = (float) value.third().realValue();
    Point3f pntCoord[] = new Point3f[1];
    pntCoord[0] = new Point3f(x, y, z);

    // create point3d
    PointArray pnt = new PointArray(1, GeometryArray.COORDINATES);
    pnt.setCapability(GeometryArray.ALLOW_COORDINATE_READ);
    pnt.setCoordinates(0, pntCoord);

    // set standard size of point to 5.0f pixels
    PointAttributes pntAttr = new PointAttributes(pointSize, true);
    pntAttr.setCapability(PointAttributes.ALLOW_SIZE_WRITE);
    pntAttr.setCapability(PointAttributes.ALLOW_SIZE_READ);
    app.setPointAttributes(pntAttr);

    // create point shape
    Shape3D pntShape = new Shape3D(pnt, app);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_OVERRIDE_READ);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_OVERRIDE_WRITE);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_READ);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_WRITE);

    return pntShape;
    }

  /**
   * createPoints 
   * creates a point set with a given Appearance
   * 
   * @param app Appearance
   * @param value List Expression
   * @return the created PointSet as a Shape
   */
  private Shape3D createPoints(Appearance app, ListExpr value) {

     try{

    //check if Object is defined
    int length = value.listLength();

    if (length<0){
      isUndefined=true;
      return null;
    }
    
    if(length==0){
      isUndefined = false;
      return null;
    }
    
    Point3f pntCoord[] = new Point3f[length];
    for(int i=0;i<length;i++){
      ListExpr p = value.first();
      value = value.rest();
      float x = (float) p.first().realValue();
      float y = (float) p.second().realValue();
      float z = (float) p.third().realValue();
      //x = x * 100;
      //y = y * 100;
      pntCoord[i] = new Point3f(x, y, z);
    }

    // create point3d
    PointArray pnt = new PointArray(length, GeometryArray.COORDINATES);
    pnt.setCapability(GeometryArray.ALLOW_COORDINATE_READ);
    pnt.setCoordinates(0, pntCoord);
    

    // set standard size of point to 5.0f pixels
    PointAttributes pntAttr = new PointAttributes(pointSize, true);
    pntAttr.setCapability(PointAttributes.ALLOW_SIZE_WRITE);
    pntAttr.setCapability(PointAttributes.ALLOW_SIZE_READ);
    app.setPointAttributes(pntAttr);

    // create point shape
    Shape3D pntShape = new Shape3D(pnt, app);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_OVERRIDE_READ);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_OVERRIDE_WRITE);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_READ);
    pntShape.setCapability(Shape3D.ALLOW_APPEARANCE_WRITE);

    return pntShape;

    } catch(Exception e){
         e.printStackTrace();
         return null;
    }

    }

  /**
   * createVolume 
   * creates a 3D Volume or a Surface
   * 
   * @param app Appearance
   * @param value List Expression from SecondoObject or Relation tuple
   * @return volume or surface as a shape
   */
  private Shape3D createVolume(Appearance app, ListExpr value) {
    // value=( ((xyz)(xyz)(xyz)) ((xyz)(xyz)(xyz)) ((xyz)(xyz)(xyz)) )

    //check if Object is defined
    if (value.listLength()<0){
      isUndefined=true;
      return null;
    } 
    
    //check if Object is emty
    if ((value.listLength()==0)) {
      isEmpty=true;
      return null;
    }

    Point3f[] volumePnts = new Point3f[value.listLength() * 3];
    int[] volumeIndices = new int[value.listLength() * 3];

    float x, y, z;
    ListExpr firstTriangle;
    ListExpr[] pnt = new ListExpr[3];
    ListExpr restTriangles = value;

    int length = value.listLength();
    for (int i = 0; i < length; i++) {
      firstTriangle = restTriangles.first();
      restTriangles = restTriangles.rest();

      pnt[0] = firstTriangle.first();
      pnt[1] = firstTriangle.second();
      pnt[2] = firstTriangle.third();

      for (int j = 0; j < 3; j++) {
        x = (float) pnt[j].first().realValue();
        y = (float) pnt[j].second().realValue();
        z = (float) pnt[j].third().realValue();

        volumePnts[(i * 3) + j] = new Point3f(x, y, z);
        volumeIndices[(i * 3) + j] = (i * 3) + j;
        }
      }

    GeometryInfo gi = new GeometryInfo(GeometryInfo.TRIANGLE_ARRAY);
    gi.setCoordinates(volumePnts);
    gi.setCoordinateIndices(volumeIndices);
    NormalGenerator ng = new NormalGenerator();
    ng.generateNormals(gi);
    GeometryArray te = gi.getGeometryArray();
    te.setCapability(GeometryArray.ALLOW_COORDINATE_READ);

    // create shape
    Shape3D volume = new Shape3D(te, app);
    volume.setCapability(Shape3D.ALLOW_APPEARANCE_OVERRIDE_READ);
    volume.setCapability(Shape3D.ALLOW_APPEARANCE_OVERRIDE_WRITE);
    volume.setCapability(Shape3D.ALLOW_APPEARANCE_READ);
    volume.setCapability(Shape3D.ALLOW_APPEARANCE_WRITE);

    return volume;
    }

  /**
   * createRelationObjects 
   * create all Objects form Relation. This Method also
   * create the TextView in TextWindow
   * 
   * @param list List Expression from secondo Object
   */
  private void createRelationObjects(ListExpr list) {
	  
    // set varying color menu unselected
    isVaryingColorViewSelected = false;
    // create a cutting line string
    String cutLine = "----------";

    // Analyze Relation
    if (list.listLength() != 2) {
    	Reporter.showError("List Expression is not Correct ");
      } else {
        ListExpr type = list.first();
        ListExpr value = list.second();
        // Analyze type
        ListExpr maintype = type.first();
        if (type.listLength() != 2
          || !maintype.isAtom()
          || maintype.atomType() != ListExpr.SYMBOL_ATOM
          || !(maintype.symbolValue().equals("rel")
            || maintype.symbolValue().equals("mrel") || maintype
            .symbolValue().equals("trel"))) {
              Reporter.showError("List Expression is not a Relation ");
              }
        ListExpr tupletype = type.second();
        // Analyze Tuple
        ListExpr TupleFirst = tupletype.first();
        if (tupletype.listLength() != 2
          || !TupleFirst.isAtom()
          || TupleFirst.atomType() != ListExpr.SYMBOL_ATOM
          || !(TupleFirst.symbolValue().equals("tuple") || TupleFirst
            .symbolValue().equals("mtuple"))) {
              Reporter.showError("List Expression is not a Tuple ");
              }
        // Analyze Types of objects
        ListExpr TupleTypeValue = tupletype.second();
  	  
        String[] objectTypes = new String[TupleTypeValue.listLength()];
        String[] objectNames = new String[TupleTypeValue.listLength()];
        for (int i = 0; !TupleTypeValue.isEmpty(); i++) {
          ListExpr TupleSubType = TupleTypeValue.first();
          objectNames[i] = TupleSubType.first().stringValue();
          objectTypes[i] = TupleSubType.second().stringValue();
          TupleTypeValue = TupleTypeValue.rest();
          }
        // Analyze objects values
        ListExpr valRow;
        // group for
        TransformGroup relationGroup = new TransformGroup();
        // relation

        int length = value.listLength();
        currentTupleLength = value.first().listLength();
        for (int i = 0; i < length; i++) {
          valRow = value.first();
         
          // Transform group for each tuple
          TransformGroup tupleGroup = new TransformGroup();
          // shape vector for each tuple
          Vector<Shape3D> shapesOfTupleVector = new Vector<Shape3D>();

          for (int j = 0; !valRow.isEmpty(); j++) {
            TransformGroup elemGroup = new TransformGroup();
            Shape3D elem = null;
            Appearance app = createAppearance();
            
            // get the type from String[]
            switch (objectTypes[j]) {
              case "point3d":
              case "vector3d":
              elem = createPoint(app, valRow.first());
                break;
              case "pointcloud":
              elem = createPoints(app, valRow.first().rest());
              break;
              case "surface3d":
              case "volume3d":
              elem = createVolume(app, valRow.first());
                break;
              default:
              elem = null;
            }
            
            if (elem != null) {
              elemGroup.addChild(elem);
              tupleGroup.addChild(elemGroup);
              objectAppearanceVector.add(app);
              objectNameVector.add(new String(objectTypes[j]
                .toString()));
              setTextView(objectNames[j] + ": " + objectTypes[j],
                null);
              elemGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
              elemGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
              tfgVector.add(elemGroup);
              int index = i * (currentTupleLength + 1) + j;
              elem.setUserData(index);
            } else {
              setTextView(objectNames[j], valRow.first());
            }

            shapesOfTupleVector.add(elem);
            valRow = valRow.rest();
           }

          shapeVector.add(shapesOfTupleVector);
          setTextView(cutLine, null);
          relationGroup.addChild(tupleGroup);
          value = value.rest();
          }
        objectTransGrp.addChild(relationGroup);
        }
    }

  /**
   * setTextView 
   * creates the text view wich is shown in Spatial3DViewer 
   * fo Relations.
   * Each time it is invoked it put an item to the TextWindow.
   * 
   * @param objectName
   * @param objectValue
   */
  private void setTextView(String objectName, ListExpr objectValue) {
    if (objectValue != null) {
      String value = objectValue.writeListExprToString();
      value = value.replaceAll("\\r\\n|\\r|\\n", "");
      textViewItems.add(objectName + ": " + value);
      } else {
        textViewItems.add(objectName);
        }
    }

  /**
   * createAppearance 
   * create a standard appearance for the 3D object. In this Appearance
   * the last selected color is set. Also the distinction between 
   * grid view and full view is made.
   * 
   * @return new Appearance
   */
  private Appearance createAppearance() {
    Appearance app = new Appearance();
    PolygonAttributes polygAttr = new PolygonAttributes();
    polygAttr.setCullFace(PolygonAttributes.CULL_NONE);
    
    if (drawGrid) {
      setDefaultAppearance(app, gridColor);
//       PolygonAttributes polygAttr = new PolygonAttributes();
      polygAttr.setPolygonMode(PolygonAttributes.POLYGON_LINE);
//       app.setPolygonAttributes(polygAttr);
      } else {
        setDefaultAppearance(app, objectColor);
//         PolygonAttributes polygAttr = new PolygonAttributes();
//         polygAttr.setCullFace(PolygonAttributes.CULL_NONE);
//         app.setPolygonAttributes(polygAttr);
        }
    app.setPolygonAttributes(polygAttr);
    return app;
    }

/**
 * setDefaultAppearance 
 * This Mehtod is invoked from createAppearance() and creates a
 * default appearance.
 */

  private void setDefaultAppearance(Appearance app, Color3f col) {
    // set Material
    Material appMaterial = new Material(col, col, col, col, 120.0f);
    appMaterial.setCapability(Material.ALLOW_COMPONENT_READ);
    appMaterial.setCapability(Material.ALLOW_COMPONENT_WRITE);
    app.setMaterial(appMaterial);

    // set coloring attribute
    ColoringAttributes colAttr = new ColoringAttributes();
    colAttr.setCapability(ColoringAttributes.ALLOW_COLOR_WRITE);
    colAttr.setColor(col);
    app.setColoringAttributes(colAttr);

    // set Capability from Appearance
    app.setCapability(Appearance.ALLOW_COLORING_ATTRIBUTES_READ);
    app.setCapability(Appearance.ALLOW_COLORING_ATTRIBUTES_WRITE);
    app.setCapability(Appearance.ALLOW_MATERIAL_READ);
    app.setCapability(Appearance.ALLOW_MATERIAL_WRITE);
    app.setCapability(Appearance.ALLOW_POINT_ATTRIBUTES_READ);
    app.setCapability(Appearance.ALLOW_POINT_ATTRIBUTES_WRITE);
    app.setCapability(Appearance.ALLOW_POLYGON_ATTRIBUTES_READ);
    app.setCapability(Appearance.ALLOW_POLYGON_ATTRIBUTES_WRITE);
    }

  /**
   * changeObjectsColor 
   * change the color of all objects stored in this object group
   */
  public void changeObjectsColor() {
    int size = objectAppearanceVector.size();
    Iterator<Appearance> it = objectAppearanceVector.iterator();
    Appearance app;

    if (isVaryingColorViewSelected && isRelation) {
      Color3f[] varCol = calcVaryingColor(size);
      for (int i = 0; i < size; i++) {
        app = (Appearance) it.next();
        changeColor(app, varCol[i]);
        }
      } else {
        // set the standard color
        for (int i = 0; i < size; i++) {
          app = (Appearance) it.next();
          if (drawGrid)
          changeColor(app, gridColor);
          else
          changeColor(app, objectColor);
      }
    }
  }

  /**
  * calcVaryingColor 
  * determines the color of all objects. 
  * The colors approximate between two selected colors.
  */
  private Color3f[] calcVaryingColor(int size) {

	  Color3f[] newColor = new Color3f[size];
    
    // choose colors
     firstSelCol = JColorChooser.showDialog(null,
      "Choose first Color!", objectColor.get());
     secSelCol = JColorChooser.showDialog(null,
      "Choose second Color!", objectColor.get());
      
    //calc new colors in HSB color Space    
    float [] hsbFirst = Color.RGBtoHSB(firstSelCol.getRed(),
      firstSelCol.getGreen(), firstSelCol.getBlue(), null);
    float [] hsbSecond = Color.RGBtoHSB(secSelCol.getRed(),
      secSelCol.getGreen(), secSelCol.getBlue(), null);
    // calc hue
    float minHue = Math.min(hsbFirst[0], hsbSecond[0]);
    float maxHue = Math.max(hsbFirst[0], hsbSecond[0]);
    double offsetHue = (double)(maxHue - minHue)/(double)size;
    //calc saturation
    float minSat = Math.min(hsbFirst[1], hsbSecond[1]);
    float maxSat = Math.max(hsbFirst[1], hsbSecond[1]);
    double offsetSat = (double)(maxSat - minSat)/(double)size;
    // calc brightness
    float minBright = Math.min(hsbFirst[2], hsbSecond[2]);
    float maxBright = Math.max(hsbFirst[2], hsbSecond[2]);
    double offsetBright = (double)(minBright - maxBright)/(double)size;
    
    double newHue = minHue;
    double newSat = minSat;
    double newBright = minBright;
    int rgb;
    
    for (int i = 0; i < size; i++) {
      newHue=minHue+offsetHue*(double)i;
      newSat=minSat+offsetSat*(double)i;
      newBright=minBright+offsetBright*(double)i;
      
      rgb = Color.HSBtoRGB((float)newHue, (float)newSat, (float)newBright);
      
      newColor[i] = new Color3f(new Color((rgb>>16)&0xFF, (rgb>>8)&0xFF,
        rgb&0xFF));
    }

    return newColor;
   
    
    }


  /**
   * changeColor 
   * change Color from current Shape in the passed color
   * 
   * @param col Color which was chosen
   */
  public void changeColor(Color col) {
    Appearance app = currentShape.getAppearance();
    Color3f color = new Color3f();
    color.set(col);
    changeColor(app, color);
    }

  /**
   * changeColor 
   * changes the color of the passed appearance in the passed color
   * 
   * @param app in this appearance, the color is changed
   * @param col this is the chosen color
   */
  private void changeColor(Appearance app, Color3f col) {
    Material mat = app.getMaterial();
    mat.setAmbientColor(col);
    mat.setEmissiveColor(col);
    mat.setDiffuseColor(col);
    mat.setSpecularColor(col);
    ColoringAttributes colAttr = app.getColoringAttributes();
    colAttr.setColor(col);
    PolygonAttributes polygAttr = new PolygonAttributes();
    polygAttr.setCullFace(PolygonAttributes.CULL_NONE);
    if (drawGrid) {
      polygAttr.setPolygonMode(PolygonAttributes.POLYGON_LINE);
      app.setPolygonAttributes(polygAttr);
      } else {
        polygAttr.setPolygonMode(PolygonAttributes.POLYGON_FILL);
        app.setPolygonAttributes(polygAttr);
        }
    }

  /**
   * changeBackgroundColor 
   * opens a color dialog and set Background color tho the given color
   * in the global variable backgroundColor
   */
  public void changeBackgroundColor() {
    Color selColor = JColorChooser.showDialog(null,
      "Choose the background color!", backgroundColor.get());
    if (selColor != null) {
      if (!selColor.equals(backgroundColor.get())) {
        backgroundColor.set(selColor);
        background.setColor(backgroundColor);
        }
      }
    }

  /**
   * changeSinglePointSize 
   * change point size from the current Shape,  which is a point
   * 
   * @param pntSize is the selected pointSize
   */
  public void changeSinglePointSize(float pntSize) {
    PointAttributes pntAtr = currentShape.getAppearance()
    .getPointAttributes();
    if (pntAtr != null) {
      pntAtr.setPointSize(pntSize);
      }
    }

  /**
   * changeAllPointSize 
   * changes every point size in the selected pointSize
   * 
   * @param pntSize is the selected pointSize
   */
  public void changeAllPointSize(float pntSize) {
    pointSize = pntSize;
    int size = objectAppearanceVector.size();
    Iterator<Appearance> objAppIt = objectAppearanceVector.iterator();
    Iterator<String> objNameIt = objectNameVector.iterator();
    Appearance app;
    String name;

    for (int i = 0; i < size; i++) {
      app = (Appearance) objAppIt.next();
      name = (String) objNameIt.next();
      // set Pointsize
      if (name.equals("point3d"))
      app.getPointAttributes().setPointSize(pntSize);
      }
    }

  /**
   * changeScaleFactor 
   * change the scale factor for the current object group by
   * manipulating the scaleTransformGroup. This TransformGroup is not
   * used by any other method or Transforming operations,  therefore here 
   * is the scaleFactor the only factor which is changed.
   */
  private void changeScaleFactor() {
    Transform3D scale = new Transform3D();
    scale.setScale(scaleFactor);
    scaleTransGrp.setTransform(scale);
    }

  /**
   * addMouseBehavior 
   * adds the Mouse Behaviors to the object 
   * (translate, rotate, zoom,  pick)
   * 
   * @param object TransformGroup
   * @return object the same TransformGroup which was passed with 
   * mouse behaviors
   */
  private TransformGroup addMouseBehavior(TransformGroup object) {
    BoundingSphere behaveBounds = new BoundingSphere(new Point3d(0.0, 0.0,
      0.0), Double.MAX_VALUE);

    // Rotation
    pickRotate = new CustomPickRotate(rootScene, canvas, behaveBounds);
    object.addChild(pickRotate);
        
    // Translate
    pickTranslate = new CustomPickTranslate(rootScene, canvas,
      behaveBounds);
    object.addChild(pickTranslate);

    // Zoom
    pickZoom = new CustomPickZoom(rootScene, canvas, behaveBounds);
    object.addChild(pickZoom);

    // WheelZoom
    wheelZoom = new CustomPickMouseWheelZoom(rootScene, canvas,
      behaveBounds);
    object.addChild(wheelZoom);

    // RelationPick
    if (isRelation) {
      relationPicking = new RelationPicking( viewer, rootScene,
        canvas, behaveBounds);
      object.addChild(relationPicking);
    }
    
    return object;  
    }

  /**
   * calcBounds 
   * calculates the Bounds of the TransformGroup. Then the method 
   * scale the passed TransformGroup in the View automatically.
   * 
   * @param group
   * @return translateTransGrp a new TransformGroup which 
   * contains the passed TransformGroup group
   */
  private TransformGroup calcBounds(TransformGroup group) {
    Bounds tfGoupBounds = group.getBounds();
    BoundingSphere sphere = new BoundingSphere(tfGoupBounds);
    translateTransGrp.setTransform(calcAutoTransform(sphere, !isRelation));
    translateTransGrp.addChild(group);
    
   
    // set scaleFactor automatically
    if (autoScaleFactor && !isSinglePoint) {
      scaleFactor = calcAutoScaleFactor(sphere);
      } else {
        if (autoScaleFactor && isSinglePoint)
        scaleFactor = 0.1;
        }
    return translateTransGrp;
    }

  /**
   * calcAutoTransform 
   * Calculate a Transform3D objet to positions the TransformGroup, which 
   * contains the Object(s), in the center of the view.
   * 
   * @param sphere BoundingSphere from TransformGroup which contains the object(s)
   * @param boolean is True if the method should also calculate in Z direction
   * @return posMiddle Transform3D which centers the TransformGroup
   */
  private Transform3D calcAutoTransform(BoundingSphere sphere, boolean calcZ) {
    // put TF group in the middle of view
    Point3d tfCenter = new Point3d();           // get the center coordinates of
    // sphere
    sphere.getCenter(tfCenter);
    double[] coord = new double[3];
    tfCenter.get(coord);
    float zOffset;

    float xOffset = (float) (coord[0] * -1.0);  // calc offset of coordinates
    float yOffset = (float) (coord[1] * -1.0);
    if (calcZ)
      zOffset = (float) ((coord[2]+4.0f) * -1.0 );
    else
      zOffset = 0.0f;                                     

    Transform3D posMiddle = new Transform3D();  // put object in the middle
    posMiddle.setTranslation(new Vector3f(xOffset, yOffset, zOffset));

    return posMiddle;

    }
  

  /**
   * calcAutoScaleFactor 
   * calculate automatically the scale factor to fit
   * objects into canvas
   * 
   * @param sphere BoundingSphere from Object which should center in the view
   * @return factor is the scale factor
   */
  private double calcAutoScaleFactor(BoundingSphere sphere) {
    double factor;
    factor= 1.0/sphere.getRadius();
    if (factor > 1.0) {
      factor = 1.0;
      }
    if (factor < 0.0001) {
      factor = 0.0001;
      }
    return factor;
    }

  /**
   * updateView 
   * put all transformgroups tho the scene graph
   * 
   * @param group
   */
  private void updateView(TransformGroup group) {
    
    // set Background color
    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
      Double.MAX_VALUE);
    background = new Background(backgroundColor);
    background.setApplicationBounds(bounds);
    background.setCapability(Background.ALLOW_COLOR_WRITE);
    rootScene.addChild(background);

    try {
      pickZoom.setFactor(zoomFactor);     // standard is 0.04
      wheelZoom.setFactor(zoomFactor);    // standard is 0.1
      // standard is 0.2
      pickTranslate.setFactor(translateFactor);
      pickRotate.setFactor(rotateFactor); // standard is 0.03
      } catch (NullPointerException e) {
        }

    // set Scale factor
    Transform3D scaleTrans = new Transform3D(); // set scaleFactor to scale
    // Transform3D
    scaleTrans.setScale(scaleFactor);
    scaleTransGrp.setTransform(scaleTrans);

    // put Object 4 meters away
    Transform3D transform = new Transform3D();
    transform.setTranslation(new Vector3f(0.0f, 0.0f, -4.0f));
    TransformGroup trans = new TransformGroup(transform);

    // add children
    scaleTransGrp.addChild(group);
    trans.addChild(scaleTransGrp);
    rootScene.addChild(trans);
    // compile Scene
    rootScene.compile();

    }

  /**
   * showSelectedObject 
   * select Object which was choose from TextView. The current 
   * object will be rotated back and centered
   * 
   * @param index from selected object
   */
  public void showSelectedObject(int index) {
    setCurrentShape(index);
    if (currentShape != null) {
      Bounds shapeBound = currentShape.getBounds();
      BoundingSphere shapeSphere = new BoundingSphere(shapeBound);
      //if it is not point set scale Factor
      if (! (currentShape.getGeometry() instanceof PointArray)) {
          setScaleFactor((calcAutoScaleFactor(shapeSphere)), false);
      }
      // set rotation
      rotateRelationBack();

      //calc center position
      Transform3D transTFGTransform = new Transform3D();
      translateTransGrp.getTransform(transTFGTransform);
      calcCenterPosition(currentShape, translateTransGrp, transTFGTransform);
      translateTransGrp.setTransform(transTFGTransform);
    }
  }
  
  /**
   * rotateRelationBack
   * brings the relation with respect to rotation in starting position
   */
  private void rotateRelationBack() {
    Matrix3f rotationTFG = new Matrix3f();
    //get rotation from shape
    rotationTFG= pickRotate.getRotation();
    rotationTFG.invert();
    //rotate each shape in Relation
    Iterator<TransformGroup> tfgIt = tfgVector.iterator();
    Shape3D shape;
    while (tfgIt.hasNext()) {
      Transform3D currTF = new Transform3D();
      TransformGroup grp =tfgIt.next();    
      grp.getTransform(currTF);
      currTF.setRotation(rotationTFG);
      grp.setTransform(currTF);
    }
  }
  
  /**
   * calcCenterPosition
   * calculate from a given object in a Relation the position
   * and centered it in the display
   * 
   * @param shape is the object which should be centered
   * @param group is the TransformGroup which contains all objects
   * @param transform is the Transform3D object which should be transformed
   */
  private void calcCenterPosition(Shape3D shape,  TransformGroup group,  Transform3D transform) {
    group.getTransform(transform);
    //get shape position
    Bounds shapeBound = shape.getBounds();
    BoundingSphere shapeSphere = new BoundingSphere(shapeBound);
    double radiusShape = shapeSphere.getRadius() ;
    Point3d centerShape = new Point3d();
    shapeSphere.getCenter(centerShape);
    
    //get transform group position
    Bounds groupBound = group.getBounds();
    BoundingSphere groupSphere = new BoundingSphere(groupBound);
    double radiusGroup = groupSphere.getRadius() ;
    Point3d centerGroup = new Point3d();
    groupSphere.getCenter(centerGroup);
    
    double[] centerShapeCoord = new double[3];
    double[] centerGroupCoord = new double[3];
    double[] centerStandTFGCoord = new double[3];
    
    centerShape.get(centerShapeCoord);
    centerGroup.get(centerGroupCoord);
    standardCenterTFG.get(centerStandTFGCoord);
    float[] newCoord = new float[3];
    for (int i=0; i<3; i++) {
      newCoord[i]=(float) (centerShapeCoord[i]+centerGroupCoord[i]-centerStandTFGCoord[i])*-1.0f;
    }
    transform.setTranslation(new Vector3f(newCoord));
  }
 
  /**
   * selectObject 
   * returns the desired object that would be searched via the passed index. 
   * If index ==(-1) currentShape = Null.
   * 
   * @param index
   * @return shape
   */
  private Shape3D selectObject(int index) {
    if (index < 0) {
      return null;
      } else {
        Shape3D shape = null;
        // index is not a split line
        if (((index + 1) % (currentTupleLength + 1)) != 0) {
          int cntRows = shapeVector.size();

          if (cntRows != 0 && currentTupleLength != 0) {
            int row = (int) Math.floor(index / (currentTupleLength + 1));
            // +1 because of split Line
            int column = (int) index % (currentTupleLength + 1);
            try {
              shape = shapeVector.get(row).get(column);
              } catch (Exception e) {
                Reporter.writeError("Error in showObject= "
                  + e.getStackTrace());
                Reporter.writeError("Error in showObject= "
                  + e.getClass() + " - " + e.getMessage() + " - "
                  + e.getCause());
                }
            }
          }
        return shape;
    }
  }
      
  /**
   * centeringView 
   * Returns the display in starting position while retaining 
   * the settings of the objects
   */
  public void centeringView() {
    rotateRelationBack();
    //calc bounds
    Bounds tfGoupBounds = translateTransGrp.getBounds();
    BoundingSphere sphere = new BoundingSphere(tfGoupBounds);
    // set translation to middle position
    translateTransGrp.setTransform(calcAutoTransform(sphere, true));
    // calc automatic scale factor
    setScaleFactor(calcAutoScaleFactor(sphere), false);
//     
  }

/** getter and setter --------------------------------- */

  /** SecondoObject */
  public SecondoObject getSecondoObject() {
    return secondoObject;
    }

  /** isRelation */
  public boolean isRelation() {
    return isRelation;
    }
  
  /** isUndefined*/
  public boolean isUndefined() {
    return isUndefined;
  }
  
  /**isEmpty*/
  public boolean isEmpty() {
    return isEmpty;
  }

  /** textViewItems */
  public Vector<String> getTextViewItems() {
    return textViewItems;
    }

  /** currentTypeString */
  public String getCurrentType() {
    return currentTypeString;
    }

  /** objectTfGrp */
  public TransformGroup getObjetTrfGrp() {
    return objectTransGrp;
    }

  /** isVaryingColorViewSelected */
  public boolean getVaryingColorViewSelected() {
    return isVaryingColorViewSelected;
    }

  public void setVaryingColorViewSelected(boolean isSelected) {
    isVaryingColorViewSelected = isSelected;
    }

  /** drawGrid */
  public boolean getDrawGrid() {
    return drawGrid;
    }

  public void setDrawGrid(boolean grid) {
    if (grid != drawGrid) {
      drawGrid = grid;
      changeObjectsColor();
      }

    }

  /** currentShape */
  public Shape3D getCurrentShape() {
    return currentShape;
    }

  public void setCurrentShape(int index) {
    currentShape = selectObject(index);
    }

  /** scaleFactor */
  public double getScaleFactor() {
    return scaleFactor;
    }

  public void setScaleFactor(double factor, boolean setAuto) {
    scaleFactor = factor;
    autoScaleFactor = setAuto;
    changeScaleFactor();
    }

  /** autoScaleFactor */
  public boolean getAutoScaleFactor() {
    return autoScaleFactor;
    }

  public void setAutoScaleFactor(boolean auto) {
    autoScaleFactor = auto;
    }

  /** zoomFactor */
  public double getZoomFactor() {
    return zoomFactor;
    }

  public void setZoomFactor(double factor) {
    zoomFactor = factor;
    //TODO new
    lightingPanel.setZChangeFactor(factor);
    try {
      pickZoom.setFactor(zoomFactor);     // standard is 0.04
      wheelZoom.setFactor(zoomFactor);    // standard is 0.1
      } catch (NullPointerException e) {
        }
    }

  /** translateFactor */
  public double getTranslateFactor() {
    return translateFactor;
    }

  public void setTranslateFactor(double factor) {
    translateFactor = factor;
    //TODO new
    lightingPanel.setXChangeFactor(factor);
    lightingPanel.setYChangeFactor(factor);
    try {
      // standard is 0.02
      pickTranslate.setFactor(translateFactor);
      } catch (NullPointerException e) {
        }
    }

  /** rotateFactor */
  public double getRotateFactor() {
    return rotateFactor;
    }

  public void setRotateFactor(double factor) {
    rotateFactor = factor;
    try {
      pickRotate.setFactor(rotateFactor); // standard is 0.03
      } catch (NullPointerException e) {
        }
    }
  
  /** pointSize */
  public double getPointSize() {
    return pointSize;
    }

  public void setSinglePointSize(float sPntSize) {
    singlePointSize = sPntSize;
    }

  public float getSinglePointSize() {
    return singlePointSize;
    }

  /** objectColor */
  public Color3f getObjectColor() {
    return objectColor;
    }

  public void setObjectColor(Color color) {
    objectColor.set(color);
    if(!drawGrid){
      setVaryingColorViewSelected(false);
      changeObjectsColor();
      }
    }

  /** gridColor */
  public Color3f getGridColor() {
    return gridColor;
    }

  public void setGridColor(Color color) {
    gridColor.set(color);
    if(drawGrid){
      setVaryingColorViewSelected(false);
      changeObjectsColor();
      }
    }

  /** set default colors */
  public void setDefaultBackgroundColor() {
    backgroundColor.set(DEFAULT_BACKGROUND_COLOR.get());
    background.setColor(backgroundColor);
    }

  public void setDefaultObjectColor() {
    objectColor.set(DEFAULT_OBJECT_COLOR.get());
    if(!drawGrid){
      setVaryingColorViewSelected(false);
      changeObjectsColor();
      }
    }

  public void setDefaultGridColor() {
    gridColor.set(DEFAULT_GRID_COLOR.get());
    if(drawGrid){
      setVaryingColorViewSelected(false);
      changeObjectsColor();
    }
  }

 /** end of getter and setter ----------------------- */
 
  /**
   * add an individual light
   * @param light branch group, to which a light gets added.
   */
  public void addLight(BranchGroup lightBg){
    lights.addChild(lightBg);
    }
  /**
   * return the light at index
   * @param index: index for selected light
   * @return returns the LightBranchGroup at the given index
   */
  public LightBranchGroup getLight(int index){
    if(index < 0 || index >= lights.numChildren()) return null;
    int j=0;
    for(int i=0;i<index;i++){
      if(!(lights.getChild(i) instanceof LightBranchGroup) ){
        j++;
        }
      j++;
      }
    if(j >= lights.numChildren()) return null;
    return (LightBranchGroup)lights.getChild(j);
    }
  /**
   * delete a light at index
   * @param index: index for selected light
   */
  public void delLight(int index){
    if(index<0 || index > lights.numChildren()-1) return;
    lights.removeChild(index);
    }

  /**
   * getter LightColor
   * @return color of ambient light
   */
  public Color3f getLightColor(){
    Color3f color = new Color3f();
    ambLight.getColor(color);
    return color;
    }

  /**
   * setter LightColor
   * @param color
   */
  public void setLightColor(Color color){
    if(color==null)return;
    Color3f color3f = new Color3f(color);
    ambLight.setColor(color3f);
    }

  /**
   * setter on / off ambLight
   * @param switch on/off
   */
  public void setMainLightSwitch(boolean sw){
    if(ambLight!=null) ambLight.setEnable(sw);
    }

  /**
   * getter on/off ambLight
   * @return on/off of AmbientLight
   */
  public boolean getMainLightSwitch(){
    if(ambLight==null)return false;
    return ambLight.getEnable();
    }

  /**
   * activate mouse movement only selected light at index
   * @param index of the light
   */
  public void setLightMouseMove(int index){
    for(int i = 0; i<lights.numChildren()-1 ; i++){
      if(lights.getChild(i) instanceof LightBranchGroup){
        ((LightBranchGroup)lights.getChild(i)).setMouseMoveEnable(false);
        }
      }
    if(lights.getChild(index) instanceof LightBranchGroup)((LightBranchGroup)lights.getChild(index)).setMouseMoveEnable(true);
    }

  /**
   * getter Ambient Lights
   * @return Ambient Lights
   */
  public BranchGroup getAmLightBg() {
    return ambLightBg;
    }
  
  /**
   * getter lights
   * @return lights
   */
  public BranchGroup getLights() {
    return lights;
    }

  /**
   * getLightingPanel
   */
  public LightPanel getLightingPanel() {
    return lightingPanel;
    }
        
}