/**
 * GeomSSCanvas3D -- The 3D canvas used by the GeomSS application.
 *
 * Copyright (C) 2009-2015, by Joseph A. Huwaldt. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place -
 * Suite 330, Boston, MA 02111-1307, USA. Or visit: http://www.gnu.org/licenses/lgpl.html
 */
package geomss.app;

import com.sun.j3d.utils.pickfast.PickCanvas;
import com.sun.j3d.utils.universe.SimpleUniverse;
import com.sun.j3d.utils.universe.ViewingPlatform;
import geomss.GeomSSScene;
import geomss.geom.*;
import geomss.geom.Point;
import geomss.j3d.*;
import jahuwaldt.j3d.*;
import jahuwaldt.js.param.Parameter;
import jahuwaldt.js.param.ParameterVector;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;
import static java.util.Objects.requireNonNull;
import javax.measure.quantity.Length;
import javax.measure.unit.SI;
import javax.media.j3d.*;
import javax.swing.SwingUtilities;
import javax.vecmath.*;
import javolution.util.FastTable;

/**
 * The 3D canvas used by this application to display the user's geometry.
 * 
 * <p> Modified by: Joseph A. Huwaldt </p>
 * 
 * @author Joseph A. Huwaldt, Date: April 14, 2009
 * @version November 23, 2015
 */
@SuppressWarnings("serial")
public class GeomSSCanvas3D extends BGFGCanvas3D implements Printable {

    /**
     * Pre-defined view angles used with <code>setView</code>.
     */
    public enum PDViewAngle {

        RIGHT_SIDE(new Vector3d(Math.toRadians(-90), Math.toRadians(180), 0)),
        LEFT_SIDE(new Vector3d(Math.toRadians(-90), 0, 0)),
        TOP(new Vector3d(0, 0, 0)),
        BOTTOM(new Vector3d(Math.toRadians(180), 0, 0)),
        FRONT(new Vector3d(Math.toRadians(-90), Math.toRadians(90), 0)),
        REAR(new Vector3d(Math.toRadians(-90), Math.toRadians(-90), 0)),
        TOP_RIGHT_FRONT(new Vector3d(Math.toRadians(45), Math.toRadians(45), Math.toRadians(135))),
        TOP_LEFT_FRONT(new Vector3d(Math.toRadians(-45), Math.toRadians(45), Math.toRadians(45))),
        TOP_RIGHT_BACK(new Vector3d(Math.toRadians(45), Math.toRadians(-45), Math.toRadians(-135))),
        TOP_LEFT_BACK(new Vector3d(Math.toRadians(-45), Math.toRadians(-45), Math.toRadians(-45)));

        private final Matrix3d _rot = new Matrix3d();

        PDViewAngle(Vector3d euler) {
            Transform3D t3d = new Transform3D();
            t3d.setEuler(euler);
            t3d.get(_rot);
        }

        /**
         * @return the rotation matrix associated with this view angle.
         */
        public Matrix3d getRotationMatrix() {
            return _rot;
        }
    }

    //  The view platform translation amount in meters.
    private static final double VP_TRANS = 1;

    //  A reference to the public interface for this class.
    private GeomSSScene _publicInterface = new PublicInterface();

    //  The TransformGroup containing the reference axes.
    private TransformGroup _axisTG = null;

    //  The TransformGroup containing our geometry.
    private TransformGroup _geomTG = null;

    //  The group containing all our geometry.
    private BranchGroup _geomBG = null;

    //  The virtual sphere/arc ball behavior used to control the view angle.
    private final VirtualSphere _arcBall;

    //  Flag indicating if the geometry is mirrored or not.
    private boolean _isMirrored = false;

    //  The current render type.
    private RenderType _renderType = RenderType.SOLID_PLUS_WIREFRAME;

    //  Temporary storage for matricies.
    private Matrix3d _rot = new Matrix3d();
    private Transform3D _trans = new Transform3D();

    //  Parmeters used to track a mouse drag event.
    private boolean _isDragging = false;
    private int _dragStartX = -1, _dragStartY = -1;
    private int _dragCurX = -1, _dragCurY = -1;

    //  Used for picking geometry from the canvas.
    private final PickCanvas _pickCanvas;

    //  A list of items picked by the user by control-clicking/dragging.
    private FastTable<GeomElement> _pickedItems = FastTable.newInstance();
    private FastTable<Double> _pickedDistance = FastTable.newInstance();

    //  Flag indicating that the user is waiting for picked output.
    private boolean _pickFlag = false;

    //  Flag indicating that rendering is in progress.
    private boolean _isUpdating = false;

    /**
     * Constructs and initializes a new Canvas3D object that Java 3D can render into.
     *
     * @param geometry  The geometry to be displayed.
     * @param width     The width of the canvas (must be > 0).
     * @param height    The height of the canvas (must be > 0).
     * @throws IllegalArgumentException if the specified GraphicsConfiguration does not
     * support 3D rendering
     */
    public GeomSSCanvas3D(GeomElement geometry, int width, int height) {
        super(SimpleUniverse.getPreferredConfiguration());
        requireNonNull(geometry);

        this.setSize(width, height);

        //      Listen for mouse-clicks on the canvas in order to implement single point
        //  picking and changing the rotation center.
        this.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent event) {
                if (!SwingUtilities.isLeftMouseButton(event))
                    return;

                if (event.isControlDown()) {
                    //  Handle control-clicks.
                    handlePicking(event.getX(), event.getY());
                    _pickFlag = false;

                } else {
                    //  Handle normal clicks.
                    int clicks = event.getClickCount();
                    if (clicks == 2) {
                        changeRotationCenter(event);
                    }
                }
            }
        });

        // Create a simple universe using our canvas.
        SimpleUniverse simpleU = new SimpleUniverse(this);

        //      Define the ViewPlatform location.
        Transform3D vpT = new Transform3D();
        vpT.set(new Vector3d(0, 0, VP_TRANS));                  //      Translation in meters

        // This will move the ViewPlatform to the specified position.
        ViewingPlatform vp = simpleU.getViewingPlatform();
        vp.getViewPlatformTransform().setTransform(vpT);

        // Create the scene graph for our model.
        BranchGroup scene = createSceneGraph(geometry);

        //      Set up for mouse input.
        BoundingSphere bounds = new BoundingSphere(new Point3d(), Double.POSITIVE_INFINITY);
        _arcBall = new VirtualSphere(this);
        _arcBall.setTransformGroup(_geomTG);
        _arcBall.setSchedulingBounds(bounds);
        _geomTG.addChild(_arcBall);

        //      Display visual feedback for the virtual sphere in the canvas.
        this.addOverlay(_arcBall.getFeedbackOverlay());

        //      Add a transform listener that rotates the reference axis view to match the geometry.
        _arcBall.addTransformChangeListener(new TransformChangeListener() {

            //  Handles the transform change event.
            @Override
            public void transformChanged(TransformChangeEvent event) {
                //      Only handle rotate events.
                if (event.getType().equals(TransformChangeEvent.Type.ROTATE)) {
                    Transform3D newRot = event.getTransform();

                    //  Get the rotational part of the new transform.
                    newRot.get(_rot);

                    //  Change the axis rotation to match the new rotation.
                    _axisTG.getTransform(_trans);
                    _trans.setRotation(_rot);
                    _axisTG.setTransform(_trans);
                }
            }
        });

        //  Create a mouse picking behavior.
        MousePickingBehavior mousePick = new MousePickingBehavior();
        mousePick.setSchedulingBounds(bounds);
        _geomTG.addChild(mousePick);

        //  Display visual feedback for the mouse picking drag-rectangle on the canvas.
        this.addOverlay(new DragRectangleOverlay());

        //      By default, center on the origin and zoom out to show a 10 meter object.
        setCenterAndZoom(new Point3d(0, 0, 0), 10);

        //      Define the pick interface.
        _pickCanvas = new PickCanvas(this, scene);
        _pickCanvas.setMode(PickInfo.PICK_GEOMETRY);
        _pickCanvas.setFlags(PickInfo.NODE | PickInfo.CLOSEST_INTERSECTION_POINT);
        _pickCanvas.setTolerance(2.0f);

        // Let Java 3D perform optimizations on this scene graph.
        scene.compile();

        //      Add the geometry scene to the universe.
        simpleU.addBranchGraph(scene);

        //      Change the front and back clip distances.
        View view = this.getView();
        view.setBackClipDistance(VP_TRANS * 10);
        view.setFrontClipDistance(VP_TRANS * 0.01);

        //      Turn on transparency geometry depth sorting.
        view.setTransparencySortingPolicy(View.TRANSPARENCY_SORT_GEOMETRY);

    }

    /**
     * A Java3D mouse behavior that draws a selection rectangle if the user control-drags
     * the mouse on the 3D canvas.
     */
    private class MousePickingBehavior extends Behavior {

        private WakeupOr mouseCriterion;

        /**
         * Initializes the behavior.
         */
        @Override
        public void initialize() {
            WakeupCriterion[] mouseEvents = new WakeupCriterion[4];

            mouseEvents[0] = new WakeupOnAWTEvent(MouseEvent.MOUSE_PRESSED);
            mouseEvents[1] = new WakeupOnAWTEvent(MouseEvent.MOUSE_RELEASED);
            mouseEvents[2] = new WakeupOnAWTEvent(MouseEvent.MOUSE_MOVED);
            mouseEvents[3] = new WakeupOnAWTEvent(MouseEvent.MOUSE_DRAGGED);

            mouseCriterion = new WakeupOr(mouseEvents);
            wakeupOn(mouseCriterion);

        }

        /**
         * Processes the MouseBehavior stimulus. This method is invoked if the Behavior's
         * wakeup criteria are satisfied and an active ViewPlatform's activation volume
         * intersects with the Behavior's scheduling region.
         *
         * @param criteria An enumeration of triggered wakeup criteria for this behavior.
         */
        @Override
        public void processStimulus(Enumeration criteria) {
            while (criteria.hasMoreElements()) {
                WakeupCriterion wakeup = (WakeupCriterion)criteria.nextElement();
                if (wakeup instanceof WakeupOnAWTEvent) {
                    AWTEvent[] events = ((WakeupOnAWTEvent)wakeup).getAWTEvent();
                    if (events.length > 0) {
                        MouseEvent evt = (MouseEvent)events[events.length - 1];
                        doProcess(evt);
                    }
                }
            }
            wakeupOn(mouseCriterion);
        }

        /**
         * Processes the mouse events doing the right thing for each.
         */
        private void doProcess(MouseEvent evt) {
            //  Do nothing if we are not in pick mode.
            if (!_pickFlag)
                return;

            //  Look for mouse moved with control key down event.
            int id = evt.getID();
            if (id == MouseEvent.MOUSE_PRESSED && evt.isControlDown()) {
                //  Mouse button pressed with the control key down.
                java.awt.Point p = evt.getPoint();
                _dragStartX = p.x;
                _dragStartY = p.y;
                _dragCurX = p.x;
                _dragCurY = p.y;
                _isDragging = true;

            } else if (_isDragging && (id == MouseEvent.MOUSE_MOVED || id == MouseEvent.MOUSE_DRAGGED)) {
                java.awt.Point p = evt.getPoint();
                _dragCurX = p.x;
                _dragCurY = p.y;

                //      Force a re-draw to show the selection rectangle.
                this.getView().repaint();

            } else if (_isDragging && id == MouseEvent.MOUSE_RELEASED) {
                _isDragging = false;

                //  Pick points throughout the selection rectangle!
                int width = _dragCurX - _dragStartX;
                boolean swapX = false;
                if (width < 0) {
                    swapX = true;
                    width *= -1;
                }
                int height = _dragCurY - _dragStartY;
                boolean swapY = false;
                if (height < 0) {
                    swapY = true;
                    height *= -1;
                }
                if (width == 0 || height == 0) {
                    handlePicking(_dragStartX, _dragStartY);
                    _pickFlag = false;
                    return;
                }

                int x0 = _dragStartX;
                int y0 = _dragStartY;
                float pickRadius = _pickCanvas.getTolerance();
                if (Math.min(width, height) < 10 * pickRadius) {
                    //  A simple grid of pick points works best for small or narrow rectangles.
                    int step = (int)(pickRadius * 2F);
                    int xf = _dragCurX;
                    if (swapX) {
                        x0 = _dragCurX;
                        xf = _dragStartX;
                    }
                    int yf = _dragCurY;
                    if (swapY) {
                        y0 = _dragCurY;
                        yf = _dragStartY;
                    }
                    for (int x = x0; x < xf; x += step) {
                        for (int y = y0; y < yf; y += step) {
                            handlePicking(x, y);
                        }
                    }

                } else {
                    //  Large rectangles:
                    //  Using a recursive circle inscribed in right triangle approach to
                    //  minimize the number of pick tests to be run.
                    circleInTrianglePick(x0, y0, width, height, !swapX, !swapY, pickRadius);
                    x0 += (swapX ? -width : width);
                    y0 += (swapY ? -height : height);
                    circleInTrianglePick(x0, y0, width, height, swapX, swapY, pickRadius);
                    _pickCanvas.setTolerance(pickRadius);
                }
                _pickFlag = false;
            }
        }

        /**
         * A recursive algorithm that inscribes a circle in a right-triangle and uses that
         * circle to pick geometry in the rectangle. Then the white space around the
         * inscribed circle is broken up into smaller right triangles and the process is
         * repeated for each until the radius of the inscribed circle is less than the
         * given tolerance.
         *
         * @param x0     The X location of the 90 deg corner of the right-triangle.
         * @param y0     The Y location of the 90 deg corner of the right-triangle.
         * @param a      The horizontal leg of the right-triangle.
         * @param b      The vertical leg of the right-triangle.
         * @param left   Indicates that the 90 deg corner of the triangle is to the left
         *               (X pos to the right, Y pos down).
         * @param bottom Indicates that the 90 deg corner is at the bottom (X pos to the
         *               right, Y pos down).
         * @param tol    The circle radius to use as a limit for recursion.
         */
        private void circleInTrianglePick(double x0, double y0, double a, double b, boolean left, boolean bottom, double tol) {

            //  Create inscribed circle for this triangle.
            double c = Math.sqrt(a * a + b * b);
            double r = (a + b - c) / 2.0;     //  Radius of circle inscribed in a right triangle.

            //  Find the center of the circle.
            double cx = (left ? x0 + r : x0 - r);
            double cy = (bottom ? y0 + r : y0 - r);

            //  Conduct the pick using the inscribed circle.
            double rad = r;
            if (rad < tol)
                rad = tol;
            _pickCanvas.setTolerance((float)rad);
            handlePicking((int)cx, (int)cy);
            if (r < tol)
                return;         //  Reached the minimum pick tolerance.

            //  Sub-divide triangle and recursively work each sub-triangle.
            //  Comment terms apply to left-bottom half of rectangle
            //  Left-bottom of square.
            double aa = 0.7 * r;
            circleInTrianglePick(x0, y0, aa, aa, left, bottom, tol);

            //  Right-bottom of square.
            double rt2 = 2 * r;
            double tr = (left ? rt2 : -rt2);
            double x1 = x0 + tr;
            double y1 = y0;
            circleInTrianglePick(x1, y1, aa, aa, !left, bottom, tol);

            //  Left-top of square.
            tr = (bottom ? rt2 : -rt2);
            double x2 = x0;
            double y2 = y0 + tr;
            circleInTrianglePick(x2, y2, aa, aa, left, !bottom, tol);

            //  Right sub-triangle.
            aa = a - rt2;
            double bb = b * aa / a;
            circleInTrianglePick(x1, y1, aa, bb, left, bottom, tol);

            //  Left sub-triangle.
            bb = b - rt2;
            aa = a * bb / b;
            circleInTrianglePick(x2, y2, aa, bb, left, bottom, tol);

            //  Finally, place a pick circle to cover a largish gap in the above coverage
            //  Even though it results in quite a bit of overlap.
            rad = 0.2 * r;
            if (rad > 2 * tol) {
                tr = 0.95 * (left ? rt2 : -rt2);
                cx = x0 + tr;
                aa = a - rt2;
                bb = b * aa / a;
                tr = 0.95 * (bottom ? bb : -bb);
                cy = y0 + tr;
                _pickCanvas.setTolerance((float)rad);
                handlePicking((int)cx, (int)cy);
            }
        }

    }   //  end class MousePickingBehavior

    /**
     * An overlay that draws a visual representation of a selection drag rectangle on the
     * 3D canvas.
     */
    private final class DragRectangleOverlay implements BGFGImage {

        private BufferedImage bufImg;
        private Graphics2D g2d;

        /**
         * Returns the overlay used to show a drag rectangle.
         */
        @Override
        public synchronized BufferedImage getImage() {
            if (!_isDragging)
                return null;

            //  Create a buffered image the size of the drag rectangle.
            int width = Math.abs(_dragCurX - _dragStartX);
            int height = Math.abs(_dragCurY - _dragStartY);
            if (width == 0 || height == 0)
                return null;
            int max = Math.max(width, height);

            //  Create a new buffered image only if the old one is to small.
            if (isNull(bufImg) || max > bufImg.getWidth()) {
                //  TYPE_INT_ARGB is required to get transparency.  However, the buffer only gets
                //  rendered as a square with the given width no matter the height specified.
                //  So, this is using the max of width & height to work around this problem
                //  which must be a bug in Java3D(?).
                bufImg = new BufferedImage(max, max, BufferedImage.TYPE_INT_ARGB);
                g2d = bufImg.createGraphics();
            }

            //  Erase the buffered image to transparent.
            clearSurface(g2d, bufImg.getWidth(), bufImg.getHeight());

            //  Draw a transparent rectangle over the selection region.
            g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f));
            Color selColor = SystemColor.textHighlight;
            g2d.setPaint(selColor);
            g2d.fillRect(0, 0, width, height);

            return bufImg;
        }

        /**
         * Clears the buffered image to be 100% transparent.
         */
        private void clearSurface(Graphics2D drawg2d, int width, int height) {
            drawg2d.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
            drawg2d.fillRect(0, 0, width + 1, height + 1);
            drawg2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
        }

        /**
         * Returns the X coordinate of the upper left corner of the drag rectangle.
         */
        @Override
        public int getImageX() {
            int diff = _dragCurX - _dragStartX;
            if (diff >= 0)
                return _dragStartX;
            return _dragStartX + diff;
        }

        /**
         * Return the Y coordinate of the upper left corner of the drag rectangle.
         */
        @Override
        public int getImageY() {
            int diff = _dragCurY - _dragStartY;
            if (diff >= 0)
                return _dragStartY;
            return _dragStartY + diff;
        }
    }   //  end class DragRectangleOverlay

    /**
     * @return the 3D scene displayed in this canvas (for use in BeanShell primarily).
     */
    public GeomSSScene getScene() {
        return _publicInterface;
    }

    /**
     * Set the viewing angle for this canvas to one of the pre-set angles.
     *
     * @param viewAngle The pre-defined viewing angle for this canvas.
     */
    public void setView(PDViewAngle viewAngle) {
        _arcBall.setRotation(viewAngle.getRotationMatrix());
    }

    /**
     * Add a <code>TransformChangeListener</code> to this canvas.
     *
     * @param listener The transform change listener to add.
     */
    public void addTransformChangeListener(TransformChangeListener listener) {
        _arcBall.addTransformChangeListener(listener);
    }

    /**
     * Remove a <code>TransformChangeListener</code> from this canvas.
     *
     * @param listener The transform change listener to remove.
     */
    public void removeTransformChangeListener(TransformChangeListener listener) {
        _arcBall.removeTransformChangeListener(listener);
    }

    /**
     * Prints the 3D model image from this canvas to the specified Graphics context using
     * the specified page format. This method is called by a PrinerJob and should not be
     * called directly by users.
     *
     * @param graphics   the context into which the page is drawn
     * @param pageFormat the size and orientation of the page being drawn
     * @param pageIndex  the zero based index of the page to be drawn.
     * @return PAGE_EXISTS if the page is rendered successfully or NO_SUCH_PAGE if
     *         pageIndex specifies a non-existent page.
     */
    @Override
    public int print(Graphics graphics, PageFormat pageFormat, int pageIndex)
            throws PrinterException {
        if (pageIndex > 0)
            return NO_SUCH_PAGE;

        //  Pause a while to let the rendering finish up.
        waitForRendering(1000);

        //      Get the current 3D model image from the frame buffer.
        BufferedImage img = getCurrentImage();

        //      Get some format information.
        double iX = pageFormat.getImageableX();
        double iY = pageFormat.getImageableY();
        double iWidth = pageFormat.getWidth();
        double iHeight = pageFormat.getHeight();

        //      Draw the image centered horizontally and at the top of the page.
        double scale = 1;
        int width = img.getWidth(this);
        if (width > iWidth)
            scale = iWidth / width;
        int height = img.getHeight(this);
        if (height * scale > iHeight)
            scale = iHeight / height;

        //      Draw the image into the supplied graphics context.
        int x = (int)((iWidth - width * scale) / 2 + iX);
        int y = (int)iY;
        graphics.drawImage(img, x, y, (int)(width * scale), (int)(height * scale), this);

        return PAGE_EXISTS;
    }

    /**
     * Create scene graph branch group.
     */
    private BranchGroup createSceneGraph(GeomElement geometry) throws IllegalArgumentException {
        BranchGroup contentRoot = new BranchGroup();

        //      Create a transform group for the reference axes.
        _axisTG = new TransformGroup();
        _axisTG.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        _axisTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        Transform3D t1 = new Transform3D();
        _axisTG.setTransform(t1);
        adjustAxisTG();

        // Create a reference axis so we can see what we are doing.
        Axis scrnAxis = new Axis((float)VP_TRANS * 0.05F, 0.45F);
        _axisTG.addChild(scrnAxis);
        contentRoot.addChild(_axisTG);

        //      Create a transform group that can be the root of the displayed geometry.
        _geomTG = new TransformGroup();
        _geomTG.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        _geomTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

        //      Create a branch group to contain all our geometry.
        _geomBG = new BranchGroup();
        _geomBG.setCapability(Group.ALLOW_CHILDREN_READ);
        _geomBG.setCapability(Group.ALLOW_CHILDREN_WRITE);
        _geomBG.setCapability(Group.ALLOW_CHILDREN_EXTEND);

        // Convert the geometry into J3D geometry.
        J3DGeomGroup geomGroup = J3DGeomGroupFactory.newGroup(this, geometry);
        _geomBG.addChild(geomGroup);

        //      Add the geometry to the transform group.
        _geomTG.addChild(_geomBG);

        //      Add the entire scene graph to the content root.
        contentRoot.addChild(_geomTG);

        // Let there be LIGHT!
        BoundingSphere lightBounds = new BoundingSphere(new Point3d(), Double.POSITIVE_INFINITY);
        AmbientLight lightA = new AmbientLight();
        lightA.setInfluencingBounds(lightBounds);
        contentRoot.addChild(lightA);

        DirectionalLight lightD1 = new DirectionalLight();
        lightD1.setInfluencingBounds(lightBounds);
        lightD1.setDirection(-15.F, -2.5F, -20.0F);
        Color3f color = new Color3f();
        color.x = 0.4f;
        color.y = 0.4f;
        color.z = 0.4f;
        lightD1.setColor(color);
        contentRoot.addChild(lightD1);

        DirectionalLight lightD2 = new DirectionalLight();
        lightD2.setInfluencingBounds(lightBounds);
        lightD2.setDirection(15.F, -2.5F, -20.0F);
        color.x = 0.4f;
        color.y = 0.4f;
        color.z = 0.4f;
        lightD2.setColor(color);
        contentRoot.addChild(lightD2);

        // Make the background white
        Background background = new Background(1.0f, 1.0f, 1.0f);
        background.setApplicationBounds(lightBounds);
        contentRoot.addChild(background);

        return contentRoot;
    }

    /**
     * Set up the transform group used by the reference axes. Uses class variables for
     * temporary storage: _trans, _rot
     */
    private void adjustAxisTG() {

        //      Get the current axis transform.
        _axisTG.getTransform(_trans);

        //      Get the rotational part of the transform.
        _trans.get(_rot);

        //      Create a translation for the axes.
        if (this.getView().getProjectionPolicy() == View.PARALLEL_PROJECTION) {
            _trans.set(new Vector3d(-0.85, -0.60, 0));
            _trans.setScale(2.5);
        } else
            _trans.set(new Vector3d(-VP_TRANS * 0.35, -VP_TRANS * 0.25, 0));

        //      Change the axis rotation to match the original rotation.
        _trans.setRotation(_rot);

        //      Store the updated transform for the axis.
        _axisTG.setTransform(_trans);

    }

    /**
     * This method is called whenever the user double-clicks on the 3D canvas. It
     * identifies if there was any geometry picked. If so, then the center of rotation is
     * moved to the picked point and the view is changed to look at the picked point.
     */
    private void changeRotationCenter(MouseEvent event) {

        //      See if the mouse point intersects the geometry anywhere.
        _pickCanvas.setShapeLocation(event);
        PickInfo pickInfo = _pickCanvas.pickClosest();

        if (nonNull(pickInfo)) {
            //  Get the picked node from the scene.
            Node pickedNode = pickInfo.getNode();

            //  Get the local to virtual world transform from the picked node.
            Transform3D locToVWorld = new Transform3D();
            pickedNode.getLocalToVworld(locToVWorld);

            //  Return the point that was picked in the scene.
            Point3d rotationPoint = pickInfo.getClosestIntersectionPoint();

            //  Transform the point to virtual world coordiantes.
            locToVWorld.transform(rotationPoint);

            //  Set this point as the rotation center.
            _arcBall.setRotationCenter(rotationPoint);
        }

    }

    /**
     * This method is called whenever the user control-clicks on the 3D canvas. It
     * identifies if there was any geometry picked and stores this in a list.
     */
    private void handlePicking(int xpos, int ypos) {
        if (!_pickFlag)
            return;

        //      See if the mouse point intersects the geometry anywhere.
        _pickCanvas.setShapeLocation(xpos, ypos);
        PickInfo[] pickInfo = _pickCanvas.pickAll();

        if (nonNull(pickInfo) && pickInfo.length > 0) {
            //  We have at least one hit.
            int size = pickInfo.length;
            for (int i = 0; i < size; ++i) {
                //      For each hit, make sure it is a GeomShape3D object.
                Node pickedNode = pickInfo[i].getNode();
                if (pickedNode != null && pickedNode instanceof GeomShape3D) {
                    //  Extract the geometry element associated with the GeomShape3D object.
                    GeomShape3D geomNode = (GeomShape3D)pickedNode;
                    GeomElement geomElement = geomNode.getGeometryElement();

                    //  Add the picked geometry to the output list (unless it is already there).
                    if (!_pickedItems.contains(geomElement)) {
                        _pickedItems.add(geomElement);

                        //  Get the closest distance from the viewpane to the geometry.
                        double dist = pickInfo[i].getClosestDistance();
                        _pickedDistance.add(dist);
                    }
                }
            }   //  Next i
        }

    }

    /**
     * Set the rotation center and zoom scale in the virtual sphere.
     *
     * @param rotCenter The center of rotation for the virtual sphere.
     * @param geomWidth The maximum width of the geometry to display in meters.
     */
    private void setCenterAndZoom(Point3d rotCenter, double geomWidth) {

        //      Get the field of view in radians.
        double fieldOfView = this.getView().getFieldOfView();

        //      Estimate the zoom distance.
        double projFactor = 0.8;
        if (_publicInterface.getProjectionPolicy() == ProjectionPolicy.PARALLEL_PROJECTION)
            projFactor = 2.0;
        double maxWidth = 2 * VP_TRANS * Math.tan(fieldOfView / 2.0) * projFactor;
        double zoomScale = maxWidth / geomWidth;

        //      Change the rotation point and zoom distance in the virtual sphere.
        _arcBall.setRotationCenter(rotCenter, zoomScale);

    }

    /**
     * Process code after we have swapped the image to the foreground.
     */
    @Override
    public void postSwap() {
        super.postSwap();
        _isUpdating = false;
    }

    /**
     * Causes the calling thread to wait until either the current rendering is complete,
     * or until the specified amount of time has elapsed. If the calling thread is
     * interrupted by any thread before or while it is waiting, then this method will
     * simply return immediately.
     *
     * @param timeout the maximum time to wait in milliseconds.
     * @throws IllegalArgumentException if the value of timeout is negative.
     */
    @SuppressWarnings("SleepWhileInLoop")
    public void waitForRendering(long timeout) throws IllegalArgumentException {
        if (timeout < 0)
            throw new IllegalArgumentException();
        long tstart = System.currentTimeMillis();
        long tend = tstart + timeout;
        try {
            while (_isUpdating && System.currentTimeMillis() < tend) {
                Thread.sleep(10);
            }
        } catch (InterruptedException e) { /* do nothing */ }
    }

    /**
     * A class that serves as the public interface (in BeanShell primarily) for this
     * application.
     */
    private class PublicInterface implements GeomSSScene {

        /**
         * Draws the specified geometry element into the 3D scene without erasing the
         * existing geometry. This is identical to <code>draw(newGeom, false);</code>.
         *
         * @param newGeom The new geometry to be displayed on the 3D canvas.
         */
        @Override
        public void draw(GeomElement newGeom) {
            draw(newGeom, false);
        }

        /**
         * Draws the specified geometry element in the 3D scene.
         *
         * @param newGeom The new geometry to be displayed on the 3D canvas.
         * @param erase   Set to <code>true</code> to erase the geometry currently
         *                displayed. Set to <code>false</code> to add the new geometry to
         *                the existing display.
         */
        @Override
        public void draw(GeomElement newGeom, boolean erase) {

            //  Deal with empty lists first by just ignoring them.
            if (newGeom instanceof GeometryList) {
                if (!((GeometryList)newGeom).containsGeometry())
                    return;
            }

            //  Indicate that the 3D scene is being updated.
            _isUpdating = true;

            //  Stop the renderer so that the changes in the scene appear in a single frame.
            View view = getView();
            boolean isRendering = view.isViewRunning();
            if (isRendering)
                view.stopView();
            try {

                //      Detach the old geometry if requested.
                if (erase)
                    erase();

                //      Create an appropriate J3D Group.
                J3DGeomGroup newGroup = J3DGeomGroupFactory.newGroup(GeomSSCanvas3D.this, newGeom);

                if (nonNull(newGroup)) {
                    //  Add the new group to the scene graph.
                    newGroup.setMirrored(isMirrored());
                    newGroup.setRenderType(_renderType);

                    //  Add the new geometry.
                    _geomBG.addChild(newGroup);
                }

            } finally {
                //  Restart the renderer before leaving.
                if (isRendering)
                    view.startView();
            }
        }

        /**
         * Erases all the geometry from the 3D scene.
         */
        @Override
        public void erase() {
            int numChildren = _geomBG.numChildren();

            //  Indicate that the 3D scene is being updated.
            _isUpdating = true;

            //  Stop the renderer so that the changes in the scene appear in a single frame.
            View view = getView();
            boolean isRendering = view.isViewRunning();
            if (isRendering)
                view.stopView();
            try {

                //      Loop over children from last to first, removing each in turn.
                for (int i = numChildren - 1; i >= 0; --i) {
                    J3DGeomGroup old = (J3DGeomGroup)_geomBG.getChild(i);
                    if (nonNull(old)) {
                        old.detach();
                    }
                }

            } finally {
                //  Restart the renderer before leaving.
                if (isRendering)
                    view.startView();
            }
        }

        /**
         * Erases the specified geometry from the 3D scene (if possible).
         */
        @Override
        public void erase(GeomElement geometry) {
            J3DGeomGroup dispGroup = (J3DGeomGroup)geometry.getUserData(J3DGeomGroup.USERDATA_KEY);
            if (nonNull(dispGroup)) {
                _isUpdating = true;
                dispGroup.detach();

            } else if (geometry instanceof GeometryList) {
                //  Indicate that the 3D scene is being updated.
                _isUpdating = true;

                //  Stop the renderer so that the changes in the scene appear in a single frame.
                View view = getView();
                boolean isRendering = view.isViewRunning();
                if (isRendering)
                    view.stopView();
                try {

                    //  A list of items was input.  If any of it's contents are displayed, erase them.
                    GeometryList<? extends GeometryList, GeomElement> lst = (GeometryList)geometry;
                    for (GeomElement item : lst) {
                        erase(item);    //      Recursively erase items in the list.
                    }

                } finally {
                    //  Restart the renderer before leaving.
                    if (isRendering)
                        view.startView();
                }
            }
        }

        /**
         * Centers the geometry in the display.
         */
        @Override
        public void center() {
            GeomList geomList = GeomList.newInstance();

            //  Get the geometry from the transform group.
            int numChildren = _geomBG.numChildren();
            for (int i = 0; i < numChildren; ++i) {
                J3DGeomGroup geomG = (J3DGeomGroup)_geomBG.getChild(i);
                GeomElement geom = geomG.getGeomElement();
                if (nonNull(geom))
                    geomList.add(geom);
            }
            if (!geomList.containsGeometry())
                return;

            //  Get the bounds of the geometry.
            GeomPoint minPnt = geomList.getBoundsMin();
            GeomPoint maxPnt = geomList.getBoundsMax();

            //  Account for the mirrored flag.
            if (isMirrored() && minPnt.getPhyDimension() > 1) {
                Parameter<Length> ymin = minPnt.get(Point.Y);
                Parameter<Length> ymax = maxPnt.get(Point.Y);
                Parameter<Length> ymino = ymin.opposite();
                Parameter<Length> ymaxo = ymax.opposite();
                Parameter<Length> yminNew = ymin.min(ymino.min(ymaxo));
                Parameter<Length> ymaxNew = ymax.max(ymaxo.max(ymino));
                if (!ymin.equals(yminNew)) {
                    MutablePoint p = MutablePoint.valueOf(minPnt);
                    p.set(Point.Y, yminNew);
                    minPnt = p;
                }
                if (!ymax.equals(ymaxNew)) {
                    MutablePoint p = MutablePoint.valueOf(maxPnt);
                    p.set(Point.Y, ymaxNew);
                    maxPnt = p;
                }
            }

            //  Find the average point in model coordinates in meters.
            ParameterVector<Length> minV = minPnt.toParameterVector();
            ParameterVector<Length> maxV = maxPnt.toParameterVector();
            Point avgPnt = Point.valueOf(minV.plus(maxV).divide(2).to(SI.METER));

            //  Indicate that the 3D scene is being updated.
            _isUpdating = true;

            //  Convert the average point from model coordinates to virtual world coordinates.
            int dim = avgPnt.getPhyDimension();
            double rotCenterX = avgPnt.getValue(0);
            double rotCenterY = (dim > 1 ? avgPnt.getValue(1) : 0);
            double rotCenterZ = (dim > 2 ? avgPnt.getValue(2) : 0);
            Point3d rotCenter = new Point3d(rotCenterX, rotCenterY, rotCenterZ);
            Transform3D model2VWorld = new Transform3D();
            _geomTG.getTransform(model2VWorld);
            model2VWorld.transform(rotCenter);

            //  Change the rotation point in the virtual sphere.
            _arcBall.setRotationCenter(rotCenter);

            //  Cleanup before leaving.
            GeomList.recycle(geomList);
        }

        /**
         * Centers the geometry in the display and zooms until the geometry fills the
         * display.
         */
        @Override
        public void centerAndZoom() {
            GeomList geomList = GeomList.newInstance();

            //  Get the geometry from the transform group.
            int numChildren = _geomBG.numChildren();
            for (int i = 0; i < numChildren; ++i) {
                J3DGeomGroup geomG = (J3DGeomGroup)_geomBG.getChild(i);
                GeomElement geom = geomG.getGeomElement();
                if (nonNull(geom))
                    geomList.add(geom);
            }
            if (!geomList.containsGeometry())
                return;

            //  Get the bounds of the geometry.
            GeomPoint minPnt = geomList.getBoundsMin();
            GeomPoint maxPnt = geomList.getBoundsMax();
            if (minPnt.isApproxEqual(maxPnt)) {
                //  If the max & min are identical, just center, don't zoom.
                center();
                return;
            }

            //  Account for the mirrored flag.
            if (isMirrored() && minPnt.getPhyDimension() > 1) {
                Parameter<Length> ymin = minPnt.get(Point.Y);
                Parameter<Length> ymax = maxPnt.get(Point.Y);
                Parameter<Length> ymino = ymin.opposite();
                Parameter<Length> ymaxo = ymax.opposite();
                Parameter<Length> yminNew = ymin.min(ymino.min(ymaxo));
                Parameter<Length> ymaxNew = ymax.max(ymaxo.max(ymino));
                if (!ymin.equals(yminNew)) {
                    MutablePoint p = MutablePoint.valueOf(minPnt);
                    p.set(Point.Y, yminNew);
                    minPnt = p;
                }
                if (!ymax.equals(ymaxNew)) {
                    MutablePoint p = MutablePoint.valueOf(maxPnt);
                    p.set(Point.Y, ymaxNew);
                    maxPnt = p;
                }
            }

            //  Find the average point in model coordinates in meters.
            ParameterVector<Length> minV = minPnt.toParameterVector();
            ParameterVector<Length> maxV = maxPnt.toParameterVector();
            Point avgPnt = Point.valueOf(minV.plus(maxV).divide(2).to(SI.METER));

            //  Indicate that the 3D scene is being updated.
            _isUpdating = true;

            //  Convert the average point from model coordinates to virtual world coordinates.
            int dim = avgPnt.getPhyDimension();
            double rotCenterX = avgPnt.getValue(0);
            double rotCenterY = (dim > 1 ? avgPnt.getValue(1) : 0);
            double rotCenterZ = (dim > 2 ? avgPnt.getValue(2) : 0);
            Point3d rotCenter = new Point3d(rotCenterX, rotCenterY, rotCenterZ);
            Transform3D model2VWorld = new Transform3D();
            _geomTG.getTransform(model2VWorld);
            model2VWorld.transform(rotCenter);

            //  Center and zoom the display to show the whole geometry.
            double geomWidth = maxV.minus(minV).norm().getValue(SI.METER);
            setCenterAndZoom(rotCenter, geomWidth);

            GeomList.recycle(geomList);
        }

        /**
         * Pick items from the scene by control-clicking with the mouse. Returns a list of
         * selected items.
         */
        @Override
        @SuppressWarnings("SleepWhileInLoop")
        public GeomList pick() {
            //  Clear the picked items list.
            _pickedItems.clear();
            _pickedDistance.clear();

            try {
                _pickFlag = true;
                _isDragging = false;
                //      Wait for the user to pick something.
                while (_pickFlag)
                    Thread.sleep(20);
            } catch (InterruptedException e) {
                _pickFlag = false;
            }

            //  Return a geometry list containing the picked items sorted by distance
            //  from view point.
            GeomList output = GeomList.newInstance();
            output.addAll(_pickedItems);
            Collections.sort(output, new PickedDistComparator());
            _pickedItems.clear();
            _pickedDistance.clear();

            return output;
        }

        /**
         * A comparator used to sort the picked items in _pickedItems by distance from the
         * view point.
         */
        private class PickedDistComparator implements Comparator<GeomElement> {

            @Override
            public int compare(GeomElement o1, GeomElement o2) {
                int idx1 = _pickedItems.indexOf(o1);
                int idx2 = _pickedItems.indexOf(o2);
                Double d1 = _pickedDistance.get(idx1);
                Double d2 = _pickedDistance.get(idx2);
                return -Double.compare(d1, d2);
            }
        }

        /**
         * Sets a flag indicating that the geometry is mirrored about the XZ plane of
         * symmetry.
         */
        @Override
        public void setMirrored(boolean mirrored) {
            _isMirrored = mirrored;
            int numChildren = _geomBG.numChildren();
            for (int i = 0; i < numChildren; ++i) {
                J3DGeomGroup geomG = (J3DGeomGroup)_geomBG.getChild(i);
                geomG.setMirrored(mirrored);
            }
        }

        /**
         * Returns a flag indicating if the geometry display is currently mirrored about
         * the XZ plane of symmetry or not.
         */
        @Override
        public boolean isMirrored() {
            return _isMirrored;
        }

        /**
         * Sets {@link GeomSS.j3d.RenderType rendering type} for all the objects currently
         * displayed in the entire scene.
         */
        @Override
        public void setRenderType(RenderType type) {
            _renderType = requireNonNull(type);
            int numChildren = _geomBG.numChildren();
            for (int i = 0; i < numChildren; ++i) {
                J3DGeomGroup geomG = (J3DGeomGroup)_geomBG.getChild(i);
                geomG.setRenderType(type);
            }
        }

        /**
         * Returns the {@link GeomSS.j3d.RenderType rendering type} for the 1st item in
         * the scene.
         */
        @Override
        public RenderType getRenderType() {
            return _renderType;
        }

        /**
         * Sets the color used when rendering points.
         */
        @Override
        public void setPointColor(Color color) {
            J3DGeomGroup.setPointColor(color);
        }

        /**
         * Returns the color used when rendering points.
         */
        @Override
        public Color getPointColor() {
            return J3DGeomGroup.getDefaultRenderingPrefs().getPointColor();
        }

        /**
         * Set the size that Point objects are rendered in pixels.
         */
        @Override
        public void setPointSize(int pixels) {
            J3DGeomGroup.setPointSize(pixels);
        }

        /**
         * Return the size that Point objects are rendered in pixels.
         */
        @Override
        public int getPointSize() {
            return J3DGeomGroup.getDefaultRenderingPrefs().getPointSize();
        }

        /**
         * Sets the color used when rendering curves and lines.
         */
        @Override
        public void setLineColor(Color color) {
            J3DGeomGroup.setLineColor(color);
        }

        /**
         * Returns the color used when rendering curves and lines.
         */
        @Override
        public Color getLineColor() {
            return J3DGeomGroup.getDefaultRenderingPrefs().getLineColor();
        }

        /**
         * Set the width that line/curve objects are rendered in pixels.
         */
        @Override
        public void setLineWidth(int pixels) {
            J3DGeomGroup.setLineWidth(pixels);
        }

        /**
         * Return the width that line/curve objects are rendered in pixels.
         */
        @Override
        public int getLineWidth() {
            return J3DGeomGroup.getDefaultRenderingPrefs().getLineWidth();
        }

        /**
         * Set the tolerance used when drawing parametric objects such as curves and
         * surfaces. This tolerance is used when determining how to subdivide parametric
         * objects for rendering. If the input value is <code>null</code> or equal to
         * <code>0</code>, it will be silently ignored.
         */
        @Override
        public void setDrawTolerance(Parameter<Length> tol) {
            J3DGeomGroup.setDrawTolerance(tol);
        }

        /**
         * Return the tolerance used when drawing parametric objects such as curves and
         * surfaces. This tolerance is used when determining how to subdivide parametric
         * objects for rendering.
         */
        @Override
        public Parameter<Length> getDrawTolerance() {
            return J3DGeomGroup.getDefaultRenderingPrefs().getDrawTolerance();
        }

        /**
         * Retrieves the current projection policy for this scene.
         */
        @Override
        public ProjectionPolicy getProjectionPolicy() {
            ProjectionPolicy policy = ProjectionPolicy.PERSPECTIVE_PROJECTION;
            View view = GeomSSCanvas3D.this.getView();
            if (view.getProjectionPolicy() == View.PARALLEL_PROJECTION)
                policy = ProjectionPolicy.PARALLEL_PROJECTION;
            return policy;
        }

        /**
         * Sets the projection policy for this scene. This specifies the type of
         * projection transform that will be generated. A value of PARALLEL_PROJECTION
         * specifies that a parallel projection transform is generated. A value of
         * PERSPECTIVE_PROJECTION specifies that a perspective projection transform is
         * generated.
         *
         * @param policy The new projection policy, one of PARALLEL_PROJECTION or
         *               PERSPECTIVE_PROJECTION.
         */
        @Override
        public void setProjectionPolicy(ProjectionPolicy policy) {
            requireNonNull(policy);
            View view = GeomSSCanvas3D.this.getView();
            if (policy == ProjectionPolicy.PERSPECTIVE_PROJECTION) {
                view.setProjectionPolicy(View.PERSPECTIVE_PROJECTION);
            } else {
                view.setProjectionPolicy(View.PARALLEL_PROJECTION);
            }
            adjustAxisTG();
        }

        /**
         * Set the color (of the specified type) used to render surfaces and point-arrays.
         *
         * @param colorType The aspect or type of the surface color that is being set.
         * @param color     The color to use for the specified type of surface color. The
         *                  alpha is ignored.
         * @see #setSurfaceAlpha
         */
        @Override
        public void setSurfaceColor(SurfaceColorType colorType, Color color) {
            requireNonNull(colorType);
            requireNonNull(color);
            J3DRenderingPrefs prefs = J3DGeomGroup.getDefaultRenderingPrefs();
            J3DGeomGroup.setDefaultRenderingPrefs(prefs.changeSurfaceColor(colorType, color));
        }

        /**
         * Get the color (of the specified type) used to render surfaces and point-arrays.
         *
         * @param colorType The aspect or type of the surface color that is being set. If
         *                  AMBIENT_AND_DIFFUSE is passed in, then only the ambient color
         *                  is returned!
         * @return The color used for the specified type of surface color. Alpha is
         *         ignored.
         * @see #getSurfaceAlpha
         */
        @Override
        public Color getSurfaceColor(SurfaceColorType colorType) {
            requireNonNull(colorType);
            return J3DGeomGroup.getDefaultRenderingPrefs().getSurfaceColor(colorType);
        }

        /**
         * Set the alpha or transparency used to render surfaces and point-arrays.
         *
         * @param alpha The alpha value to use (0.0=completely transparent, 1.0=completely
         *              opaque).
         */
        @Override
        public void setSurfaceAlpha(float alpha) {
            J3DRenderingPrefs prefs = J3DGeomGroup.getDefaultRenderingPrefs();
            J3DGeomGroup.setDefaultRenderingPrefs(prefs.changeSurfaceAlpha(alpha));
        }

        /**
         * Get the alpha or transparency used when rendering surfaces or point-arrays.
         *
         * @return The alpha value used (0.0=completely transparent, 1.0=completely
         *         opaque).
         */
        @Override
        public float getSurfaceAlpha() {
            return J3DGeomGroup.getDefaultRenderingPrefs().getSurfaceAlpha();
        }

        /**
         * Set the shininess used when rendering surfaces and point-arrays.
         *
         * @param shininess The shininess to use in the range [0.0, 1.0] where 0.0 is not
         *                  shiny and 1.0 is very shiny. Values outside this range are
         *                  clamped.
         */
        @Override
        public void setSurfaceShininess(float shininess) {
            J3DRenderingPrefs prefs = J3DGeomGroup.getDefaultRenderingPrefs();
            J3DGeomGroup.setDefaultRenderingPrefs(prefs.changeSurfaceShininess(shininess));
        }

        /**
         * Get the shininess used when rendering surfaces and point-arrays.
         *
         * @return The shininess to use in the range [0.0, 1.0] where 0.0 is not shiny and
         *         1.0 is very shiny.
         */
        @Override
        public float getSurfaceShininess() {
            return J3DGeomGroup.getDefaultRenderingPrefs().getSurfaceShininess();
        }
    }

}