// RadialLine.java

/*
This application demonstrates a fixed-length line that is manipulable
through manual picking (i.e., not with a direct manipulation renderer).
*/

import visad.*;
import visad.java3d.*;
import visad.util.Util;

import java.awt.event.*;
import java.rmi.RemoteException;
import java.util.Vector;

import javax.swing.*;

public class RadialLine {

  private static final float LENGTH = 5;
  private static final float END_X = 2;
  private static final float END_Y = 3;
  private static final double THRESHOLD = 0.1;

  public static void main(String[] args) throws Exception {
    // math types
    RealType x = RealType.getRealType("x");
    RealType y = RealType.getRealType("y");
    final RealTupleType xy = new RealTupleType(x, y);

    // mappings
    ScalarMap xmap = new ScalarMap(x, Display.XAxis);
    ScalarMap ymap = new ScalarMap(y, Display.YAxis);
    xmap.setRange(END_X - LENGTH, END_X + LENGTH);
    ymap.setRange(END_Y - LENGTH, END_Y + LENGTH);

    // display
    final DisplayImpl display = new DisplayImplJ3D("display",
      new TwoDDisplayRendererJ3D());
    display.disableAction();
    display.addMap(xmap);
    display.addMap(ymap);
    GraphicsModeControl gmc = display.getGraphicsModeControl();
    gmc.setScaleEnable(true);
    gmc.setPointSize(5.0f);

    // data references
    final DataReferenceImpl lineRef = new DataReferenceImpl("line");
    display.addReference(lineRef);

    // data objects
    doLine(xy, 0, 0, lineRef);

    display.enableEvent(DisplayEvent.MOUSE_DRAGGED);
    display.addDisplayListener(new DisplayListener() {
      private boolean isDragging = false;
      public void displayChanged(DisplayEvent e) {
        // verify mouse press or drag
        int id = e.getId();
        boolean press = id == DisplayEvent.MOUSE_PRESSED;
        boolean drag = id == DisplayEvent.MOUSE_DRAGGED;
        boolean release = id == DisplayEvent.MOUSE_RELEASED;
        if (!press && !drag && !release) return;

        // verify right mouse button only
        MouseEvent mouse = (MouseEvent) e.getInputEvent();
        if (!SwingUtilities.isRightMouseButton(mouse)) return;

        if (release) {
          isDragging = false;
          return; // done dragging
        }

        // get point coordinates
        int x = e.getX();
        int y = e.getY();
        double[] vals = pixelToDomain(display, x, y);

        // verify coordinates are close enough to the line
        if (press) {
          try {
            Gridded2DSet set = (Gridded2DSet) lineRef.getData();
            float[][] samps = set.getSamples(false);
            double[] ep1 = {samps[0][0], samps[1][0]};
            double[] ep2 = {samps[0][1], samps[1][1]};
            double dist = getDistance(ep1, ep2, vals, true);
            if (dist > THRESHOLD) return; // click is too far away
            isDragging = true;
          }
          catch (VisADException exc) { exc.printStackTrace(); }
        }
        if (!isDragging) return;

        // adjust point coordinates
        float xval = (float) vals[0];
        float yval = (float) vals[1];
        float xlen = END_X - xval;
        float ylen = END_Y - yval;
        float len = (float) Math.sqrt(xlen * xlen + ylen * ylen);
        if (!Util.isApproximatelyEqual(len, LENGTH)) {
          double lamda = LENGTH / len;
          xval = (float) (END_X + lamda * (xval - END_X));
          yval = (float) (END_Y + lamda * (yval - END_Y));
        }

        // update line
        try { doLine(xy, xval, yval, lineRef); }
        catch (Exception exc) { exc.printStackTrace(); }
      }
    });

    display.enableAction();

    // show display onscreen
    JFrame frame = new JFrame("Radial line with manual picking");
    frame.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) { System.exit(0); }
    });
    JPanel p = new JPanel();
    p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
    p.add(display.getComponent());
    frame.setContentPane(p);
    frame.setSize(400, 400);
    Util.centerWindow(frame);
    frame.show();
  }

  private static void doLine(RealTupleType rtt, float x, float y,
    DataReferenceImpl lineRef) throws VisADException, RemoteException
  {
    float[][] samples = { {x, END_X}, {y, END_Y} };
    Gridded2DSet set = new Gridded2DSet(rtt, samples, 2);
    lineRef.setData(set);
  }


  // -- Utility methods --

  /** Converts the given cursor coordinates to domain coordinates. */
  public static double[] cursorToDomain(DisplayImpl d, double[] cursor) {
    return cursorToDomain(d, null, cursor);
  }

  /** Converts the given cursor coordinates to domain coordinates. */
  public static double[] cursorToDomain(DisplayImpl d,
    RealType[] types, double[] cursor)
  {
    // locate x, y and z mappings
    Vector maps = d.getMapVector();
    int numMaps = maps.size();
    ScalarMap mapX = null, mapY = null, mapZ = null;
    for (int i=0; i<numMaps; i++) {
      if (mapX != null && mapY != null && mapZ != null) break;
      ScalarMap map = (ScalarMap) maps.elementAt(i);
      if (types == null) {
        DisplayRealType drt = map.getDisplayScalar();
        if (drt.equals(Display.XAxis)) mapX = map;
        else if (drt.equals(Display.YAxis)) mapY = map;
        else if (drt.equals(Display.ZAxis)) mapZ = map;
      }
      else {
        ScalarType st = map.getScalar();
        if (st.equals(types[0])) mapX = map;
        if (st.equals(types[1])) mapY = map;
        if (st.equals(types[2])) mapZ = map;
      }
    }

    // adjust for scale
    double[] scaleOffset = new double[2];
    double[] dummy = new double[2];
    double[] values = new double[3];
    if (mapX == null) values[0] = Double.NaN;
    else {
      mapX.getScale(scaleOffset, dummy, dummy);
      values[0] = (cursor[0] - scaleOffset[1]) / scaleOffset[0];
    }
    if (mapY == null) values[1] = Double.NaN;
    else {
      mapY.getScale(scaleOffset, dummy, dummy);
      values[1] = (cursor[1] - scaleOffset[1]) / scaleOffset[0];
    }
    if (mapZ == null) values[2] = Double.NaN;
    else {
      mapZ.getScale(scaleOffset, dummy, dummy);
      values[2] = (cursor[2] - scaleOffset[1]) / scaleOffset[0];
    }

    return values;
  }

  /** Converts the given pixel coordinates to cursor coordinates. */
  public static double[] pixelToCursor(DisplayImpl d, int x, int y) {
    MouseBehavior mb = d.getDisplayRenderer().getMouseBehavior();
    VisADRay ray = mb.findRay(x, y);
    return ray.position;
  }

  /** Converts the given pixel coordinates to domain coordinates. */
  public static double[] pixelToDomain(DisplayImpl d, int x, int y) {
    return cursorToDomain(d, pixelToCursor(d, x, y));
  }

  /**
   * Computes the minimum distance between the point v and the line a-b.
   *
   * @param a Coordinates of the line's first endpoint
   * @param b Coordinates of the line's second endpoint
   * @param v Coordinates of the standalone endpoint
   * @param segment Whether distance computation should be
   *                constrained to the given line segment
   */
  public static double getDistance(double[] a, double[] b, double[] v,
    boolean segment)
  {
    int len = a.length;

    // vectors
    double[] ab = new double[len];
    double[] va = new double[len];
    for (int i=0; i<len; i++) {
      ab[i] = a[i] - b[i];
      va[i] = v[i] - a[i];
    }

    // project v onto (a, b)
    double numer = 0;
    double denom = 0;
    for (int i=0; i<len; i++) {
      numer += va[i] * ab[i];
      denom += ab[i] * ab[i];
    }
    double c = numer / denom;
    double[] p = new double[len];
    for (int i=0; i<len; i++) p[i] = c * ab[i] + a[i];

    // determine which point (a, b or p) to use in distance computation
    int flag = 0;
    if (segment) {
      for (int i=0; i<len; i++) {
        if (p[i] > a[i] && p[i] > b[i]) flag = a[i] > b[i] ? 1 : 2;
        else if (p[i] < a[i] && p[i] < b[i]) flag = a[i] < b[i] ? 1 : 2;
        else continue;
        break;
      }
    }

    double sum = 0;
    for (int i=0; i<len; i++) {
      double q;
      if (flag == 0) q = p[i] - v[i]; // use p
      else if (flag == 1) q = a[i] - v[i]; // use a
      else q = b[i] - v[i]; // flag == 2, use b
      sum += q * q;
    }

    return Math.sqrt(sum);
  }

}