--- /dev/null
+package fr.orsay.lri.varna.applications.templateEditor;
+import java.awt.Graphics2D;
+import java.awt.Polygon;
+import java.awt.Shape;
+import java.awt.geom.CubicCurve2D;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.awt.geom.Point2D.Double;
+import java.util.ArrayList;
+
+import fr.orsay.lri.varna.applications.templateEditor.GraphicalTemplateElement.RelativePosition;
+import fr.orsay.lri.varna.exceptions.ExceptionEdgeEndpointAlreadyConnected;
+import fr.orsay.lri.varna.exceptions.ExceptionInvalidRNATemplate;
+import fr.orsay.lri.varna.models.geom.CubicBezierCurve;
+import fr.orsay.lri.varna.models.templates.RNATemplate;
+import fr.orsay.lri.varna.models.templates.RNATemplate.EdgeEndPointPosition;
+import fr.orsay.lri.varna.models.templates.RNATemplate.RNATemplateElement;
+import fr.orsay.lri.varna.models.templates.RNATemplate.RNATemplateHelix;
+import fr.orsay.lri.varna.models.templates.RNATemplate.RNATemplateUnpairedSequence;
+import fr.orsay.lri.varna.models.templates.RNATemplate.RNATemplateElement.EdgeEndPoint;
+
+public class UnpairedRegion extends GraphicalTemplateElement{
+ private RNATemplateUnpairedSequence _e;
+ public static final double DEFAULT_VECTOR_LENGTH = 35;
+ public static final double DEFAULT_VECTOR_DISTANCE = 35;
+
+ private Point2D.Double[] sequenceBasesCoords = null;
+
+ public UnpairedRegion(double x, double y, RNATemplate tmp)
+ {
+ _e = tmp.new RNATemplateUnpairedSequence("");
+ _e.setVertex5(new Point2D.Double(x,y));
+ _e.setVertex3(new Point2D.Double(x+DEFAULT_VECTOR_DISTANCE,y));
+ _e.setInTangentVectorLength(DEFAULT_VECTOR_LENGTH);
+ _e.setInTangentVectorAngle(-Math.PI/2.0);
+ _e.setOutTangentVectorLength(DEFAULT_VECTOR_LENGTH);
+ _e.setOutTangentVectorAngle(-Math.PI/2.0);
+ updateLength();
+
+ }
+
+ /**
+ * Build an UnpairedRegion object from a RNATemplateUnpairedSequence
+ * object. The RNATemplateUnpairedSequence must be connected to
+ * an helix on both sides.
+ */
+ public UnpairedRegion(RNATemplateUnpairedSequence templateSequence)
+ {
+ _e = templateSequence;
+ }
+
+ public Point2D.Double getEdge5()
+ {
+ RelativePosition r = RelativePosition.RP_CONNECT_START5;
+ Couple<RelativePosition,GraphicalTemplateElement> c = getAttachedElement(r);
+ return (isAnchored5()? c.second.getEdgePosition(c.first): _e.getVertex5());
+ }
+
+ public Point2D.Double getEdge3()
+ {
+ RelativePosition r = RelativePosition.RP_CONNECT_END3;
+ Couple<RelativePosition,GraphicalTemplateElement> c = getAttachedElement(r);
+ return (isAnchored3()? c.second.getEdgePosition(c.first): _e.getVertex3());
+ }
+
+ public Point2D.Double getCenter()
+ {
+ Point2D.Double p1 = getEdge5();
+ Point2D.Double p2 = getEdge3();
+ return new Point2D.Double((p1.x+p2.x)/2.,(p1.y+p2.y)/2.);
+ }
+
+
+ public void setEdge5(Point2D.Double d)
+ {
+ _e.setVertex5(d);
+ updateLength();
+ }
+
+ public void setEdge3(Point2D.Double d)
+ {
+ _e.setVertex3(d);
+ updateLength();
+ }
+
+ public void setCenter(Point2D.Double d)
+ {
+ Point2D.Double p1 = getEdge5();
+ Point2D.Double p2 = getEdge3();
+ double dx = p1.x-p2.x;
+ double dy = p1.y-p2.y;
+ _e.setVertex3(new Point2D.Double(d.x-dx/2.,d.y-dy/2.));
+ _e.setVertex5(new Point2D.Double(d.x+dx/2.,d.y+dy/2.));
+ invalidateCoords();
+ }
+
+
+ public boolean isAnchored5()
+ {
+ return (_e.getIn().getOtherElement()!=null);
+ }
+
+ public boolean isAnchored3()
+ {
+ return (_e.getOut().getOtherElement()!=null);
+ }
+
+
+ public static Shape bezToShape(CubicBezierCurve c)
+ {
+ GeneralPath p = new GeneralPath();
+ int nb = 9;
+ double[] tab = new double[nb];
+ for (int i=0;i<nb;i++)
+ {
+ tab[i] = (c.getApproxCurveLength()*(double)i)/(double)nb;
+ }
+ Point2D.Double[] points = c.uniformParam(tab);
+ System.out.println(points.length);
+ p.moveTo((float)points[0].x,(float)points[0].y);
+ for (int i=1;i<nb;i++)
+ {
+ Point2D.Double a = points[i];
+ System.out.println(a);
+ p.lineTo((float)a.x,(float)a.y);
+ }
+ p.lineTo((float)c.getP3().x,(float)c.getP3().y);
+ return p;
+ }
+
+
+
+ public Shape getCurve()
+ {
+ Point2D.Double p5 = getEdge5();
+ Point2D.Double p3 = getEdge3();
+ Point2D.Double t5 = getControl5();
+ Point2D.Double t3 = getControl3();
+ return new CubicCurve2D.Double(p5.x,p5.y,t5.x,t5.y,t3.x,t3.y,p3.x,p3.y);
+ //CubicBezierCurve c = new CubicBezierCurve( p5, t5, t3, p3, 30);
+ //return bezToShape(c);
+
+ }
+
+ private int estimateNumberOfBases()
+ {
+ Point2D.Double p5 = getEdge5();
+ Point2D.Double p3 = getEdge3();
+ Point2D.Double t5 = getControl5();
+ Point2D.Double t3 = getControl3();
+ CubicBezierCurve c = new CubicBezierCurve( p5, t5, t3, p3, 30);
+ // Extremities don't count as unpaired bases because they are part of the connected helix.
+ return Math.max((int)Math.round(c.getApproxCurveLength()/Helix.LOOP_DISTANCE)-1, 1);
+ }
+
+ private void updateLength()
+ {
+ this._e.setLength(estimateNumberOfBases());
+ invalidateCoords();
+ }
+
+
+ /**
+ * Mark the coordinates as invalid, ie. need to be calculated again if we want to draw them.
+ */
+ private void invalidateCoords() {
+ sequenceBasesCoords = null;
+ }
+
+ /**
+ * Calculate the positions of the unpaired bases.
+ */
+ private void calculeCoords() {
+ //System.out.println("calculate coords");
+
+ Point2D.Double p5 = getEdge5();
+ Point2D.Double p3 = getEdge3();
+ Point2D.Double t5 = getControl5();
+ Point2D.Double t3 = getControl3();
+
+ // Draw bases on curve:
+ int n = _e.getLength();
+ // We choose to approximate the Bezier curve by 10*n straight lines.
+ CubicBezierCurve bezier = new CubicBezierCurve(p5, t5, t3, p3, 10*n);
+ double curveLength = bezier.getApproxCurveLength();
+ double delta_t = curveLength / (n+1);
+ double[] t = new double[n];
+ for (int k=0; k<n; k++) {
+ t[k] = (k+1) * delta_t;
+ }
+ sequenceBasesCoords = bezier.uniformParam(t);
+ }
+
+ public void draw(Graphics2D g2d, boolean selected) {
+ Point2D.Double p5 = getEdge5();
+ Point2D.Double p3 = getEdge3();
+ Point2D.Double t5 = getControl5();
+ Point2D.Double t3 = getControl3();
+ if (selected)
+ {
+ g2d.setStroke(_dashedStroke);
+ g2d.setColor(BACKBONE_COLOR);
+ g2d.draw(getBoundingPolygon());
+ g2d.setStroke(_solidStroke);
+ drawAnchor(g2d,t5);
+ drawAnchor(g2d,t3);
+ double d5x = (t5.x-p5.x)/(t5.distance(p5));
+ double d5y = (t5.y-p5.y)/(t5.distance(p5));
+ double d3x = (t3.x-p3.x)/(t3.distance(p3));
+ double d3y = (t3.y-p3.y)/(t3.distance(p3));
+ double shift = -3.5;
+ Point2D.Double tp5 = new Point2D.Double(t5.x-shift*d5x,t5.y-shift*d5y);
+ Point2D.Double tp3 = new Point2D.Double(t3.x-shift*d3x,t3.y-shift*d3y);
+
+ drawArrow(g2d, p5, tp5, UNPAIRED_ARROW_WIDTH);
+ drawArrow(g2d, p3, tp3, UNPAIRED_ARROW_WIDTH);
+ }
+ g2d.setColor(BACKBONE_COLOR);
+ g2d.setStroke(_solidStroke);
+ g2d.draw(getCurve());
+
+ if (sequenceBasesCoords == null) {
+ calculeCoords();
+ }
+ for (int k=0; k<sequenceBasesCoords.length; k++) {
+ drawBase(g2d, sequenceBasesCoords[k]);
+ }
+
+ if (!isAnchored5())
+ {drawAnchor5(g2d,p5); }
+ else
+ { drawMagnet(g2d,p5);}
+ if (!isAnchored3())
+ {drawAnchor3(g2d,p3); }
+ else
+ { drawMagnet(g2d,p3);}
+
+ if (!isAnchored5() && !isAnchored3())
+ drawMove(g2d, getCenter());
+ }
+
+
+ public Point2D.Double getControl5()
+ {
+ Point2D.Double p5 = getEdge5();
+ double angle = _e.getInTangentVectorAngle();
+ return new Point2D.Double(p5.x+Math.cos(angle)*_e.getInTangentVectorLength(),
+ p5.y+Math.sin(angle)*_e.getInTangentVectorLength());
+ }
+
+ public Point2D.Double getControl3()
+ {
+ Point2D.Double p3 = getEdge3();
+ double angle = _e.getOutTangentVectorAngle();
+ return new Point2D.Double(p3.x+Math.cos(angle)*_e.getOutTangentVectorLength(),
+ p3.y+Math.sin(angle)*_e.getOutTangentVectorLength());
+ }
+
+ public static final double MAX_UNPAIRED_CONTROL_DISTANCE = 10.0;
+ public static final double UNPAIRED_ARROW_WIDTH = 6.0;
+
+
+
+ public Polygon getBoundingPolygon() {
+ Point2D.Double p5 = getEdge5();
+ Point2D.Double p3 = getEdge3();
+ Point2D.Double t5 = getControl5();
+ Point2D.Double t3 = getControl3();
+
+ double minx = Math.min(p5.x,Math.min(p3.x,Math.min(t5.x,t3.x)));
+ double maxx = Math.max(p5.x,Math.max(p3.x,Math.max(t5.x,t3.x)));
+ double miny = Math.min(p5.y,Math.min(p3.y,Math.min(t5.y,t3.y)));
+ double maxy = Math.max(p5.y,Math.max(p3.y,Math.max(t5.y,t3.y)));
+ minx -= 10;
+ maxx += 10;
+ miny -= 10;
+ maxy += 10;
+ int[] x = {(int)minx,(int)maxx,(int)maxx,(int)minx};
+ int[] y = {(int)miny,(int)miny,(int)maxy,(int)maxy};
+ return new Polygon(x,y,4);
+ }
+
+ public RelativePosition getClosestEdge(double x, double y) {
+ Point2D.Double p = new Point2D.Double(x,y);
+ Point2D.Double p5 = getEdge5();
+ Point2D.Double p3 = getEdge3();
+ Point2D.Double t5 = getControl5();
+ Point2D.Double t3 = getControl3();
+ Point2D.Double ct = getCenter();
+ ArrayList<Couple<java.lang.Double,RelativePosition>> v = new ArrayList<Couple<java.lang.Double,RelativePosition>>();
+ v.add(new Couple<java.lang.Double,RelativePosition>(p.distance(p5),RelativePosition.RP_CONNECT_START5));
+ v.add(new Couple<java.lang.Double,RelativePosition>(p.distance(p3),RelativePosition.RP_CONNECT_END3));
+ v.add(new Couple<java.lang.Double,RelativePosition>(p.distance(t5),RelativePosition.RP_EDIT_TANGENT_5));
+ v.add(new Couple<java.lang.Double,RelativePosition>(p.distance(t3),RelativePosition.RP_EDIT_TANGENT_3));
+ v.add(new Couple<java.lang.Double,RelativePosition>(p.distance(ct),RelativePosition.RP_INNER_MOVE));
+ double dist = java.lang.Double.MAX_VALUE;
+ RelativePosition r = RelativePosition.RP_OUTER;
+
+ for (Couple<java.lang.Double,RelativePosition> c : v)
+ {
+ if (c.first<dist)
+ {
+ dist = c.first;
+ r = c.second;
+ }
+ }
+ return r;
+ }
+
+ public RelativePosition getConnectedEdge(RelativePosition edge) {
+ switch(edge)
+ {
+ case RP_CONNECT_START5:
+ return RelativePosition.RP_CONNECT_END3;
+ case RP_CONNECT_END3:
+ return RelativePosition.RP_CONNECT_START5;
+ default:
+ return RelativePosition.RP_OUTER;
+ }
+ }
+
+ public Point2D.Double getEdgePosition(RelativePosition edge)
+ {
+ switch(edge)
+ {
+ case RP_INNER_MOVE:
+ return getCenter();
+ case RP_CONNECT_START5:
+ return getEdge5();
+ case RP_CONNECT_END3:
+ return getEdge3();
+ case RP_EDIT_TANGENT_5:
+ return getControl5();
+ case RP_EDIT_TANGENT_3:
+ return getControl3();
+ default:
+ return getEdge5();
+ }
+ }
+
+ double v2a(Point2D.Double p)
+ {
+ return (double)Math.atan2(p.y, p.x);
+ }
+
+ public void updateControl5(Point2D.Double p)
+ {
+ Point2D.Double p5 = getEdge5();
+ _e.setInTangentVectorLength(p5.distance(p));
+ Point2D.Double x = new Point2D.Double(p.x-p5.x,p.y-p5.y);
+ _e.setInTangentVectorAngle(v2a(x));
+ updateLength();
+ }
+
+ public void updateControl3(Point2D.Double p)
+ {
+ Point2D.Double p3 = getEdge3();
+ _e.setOutTangentVectorLength(p3.distance(p));
+ Point2D.Double x = new Point2D.Double(p.x-p3.x,p.y-p3.y);
+ _e.setOutTangentVectorAngle(v2a(x));
+ updateLength();
+ }
+
+ public void translate(double x, double y) {
+ _e.getVertex5().x += x;
+ _e.getVertex5().y += y;
+ _e.getVertex3().x += x;
+ _e.getVertex3().y += y;
+ invalidateCoords();
+ }
+
+ public RelativePosition getRelativePosition(double x, double y) {
+ RelativePosition rp = getClosestEdge(x, y);
+ double d = getEdgePosition(rp).distance(new Point2D.Double(x,y));
+ if (d<MAX_UNPAIRED_CONTROL_DISTANCE)
+ return rp;
+ if (getCurve().contains(new Point2D.Double(x,y)))
+ return RelativePosition.RP_INNER_GENERAL;
+ return RelativePosition.RP_OUTER;
+ }
+
+ public Shape getArea()
+ {
+ return getCurve();
+ }
+
+
+ public void attach(GraphicalTemplateElement e, RelativePosition edgeOrig, RelativePosition edgeDest) throws ExceptionInvalidRNATemplate
+ {
+ super.attach(e,edgeOrig,edgeDest);
+ if (e instanceof Helix)
+ {
+ EdgeEndPoint e1 = this.getEndPoint(edgeOrig);
+ EdgeEndPoint e2 = e.getEndPoint(edgeDest);
+ boolean parity1 = this.isIn(edgeOrig);
+ boolean parity2 = e.isIn(edgeDest);
+ if ((e1!=null)&&(e2!=null)&&(parity1!=parity2))
+ {
+ e1.disconnect();
+ e2.disconnect();
+ e1.connectTo(e2);
+ }
+ }
+ }
+
+
+ public EdgeEndPoint getEndPoint(RelativePosition r) {
+ switch(r)
+ {
+ case RP_CONNECT_START5:
+ return _e.getIn();
+ case RP_CONNECT_END3:
+ return _e.getOut();
+ }
+ return null;
+ }
+
+ public boolean isIn(RelativePosition r) {
+ switch(r)
+ {
+ case RP_CONNECT_START5:
+ return true;
+ case RP_CONNECT_END3:
+ return false;
+ }
+ return true;
+ }
+
+ public void detach(RelativePosition edge)
+ {
+ // If the underlying template element is still connected, disconnect it
+ if (getEndPoint(edge).isConnected())
+ {
+ Couple<GraphicalTemplateElement.RelativePosition, GraphicalTemplateElement> c = getAttachedElement(edge);
+ getEndPoint(edge).disconnect();
+ }
+
+ // Call the parent class detach function, which will also take care to disconnect this other endpoint of this edge
+ super.detach(edge);
+ }
+
+ public void setEdgePosition(RelativePosition edge, Point2D.Double pos) {
+ switch(edge)
+ {
+ case RP_CONNECT_START5:
+ setEdge5(pos);
+ break;
+ case RP_INNER_MOVE:
+ setCenter(pos);
+ break;
+ case RP_CONNECT_END3:
+ setEdge3(pos);
+ break;
+ case RP_EDIT_TANGENT_5:
+ updateControl5(pos);
+ break;
+ case RP_EDIT_TANGENT_3:
+ updateControl3(pos);
+ break;
+ }
+ }
+
+ public ArrayList<RelativePosition> getConnectedEdges() {
+ ArrayList<RelativePosition> result = new ArrayList<RelativePosition>();
+ result.add(RelativePosition.RP_CONNECT_START5);
+ result.add(RelativePosition.RP_CONNECT_END3);
+ return result;
+ }
+
+ public RNATemplateElement getTemplateElement() {
+ return _e;
+ }
+
+
+ public RelativePosition relativePositionFromEdgeEndPointPosition(
+ EdgeEndPointPosition pos) {
+ switch (pos) {
+ case IN1:
+ return RelativePosition.RP_CONNECT_START5;
+ case OUT1:
+ return RelativePosition.RP_CONNECT_END3;
+ default:
+ return null;
+ }
+ }
+
+
+}
git://source.jalview.org / jalview.git / blobdiff