public NavGraphEdge( int fromIdx, int toIdx, float cost, EdgeType edgeType=EdgeType.normal )
 {
     fromIdx_ = fromIdx;
     toIdx_ = toIdx;
     cost_ = cost;
     edgeType_ = edgeType;
 }

 public void add(String name, String seriesName, int issueYear, int width, int height, EdgeType type, int faceValue, double multiplier)
 {
     if (this.index < StampCatalog.MAX_NUMBER_OF_STAMPS)
     {
         this.stamps[this.index++] = new Stamp(name, seriesName, issueYear, width, height, type, faceValue, multiplier);
     }
 }

 public Edge()
 {
     type = EdgeType.Normal;
     name = "Edge";
     id = 0;
     behaviors = new List<Behavior>();
 }

 public EdgeTemplate(EdgeType type, int width, int height)
 {
     Type = type;
     Width = width;
     Height = height;
     Points = GetPoints(type, width, height);
 }

 public Edge()
 {
     type = EdgeType.Normal;
     id = 0;
     _name = "Edge_" + id;
     behaviors = new List<Behavior>();
 }

 public EdgeDescription(Vector3 pos, Direction direction,
                         EdgeType type)
 {
     position = pos;
     dir = direction;
     this.type = type;
 }

 /// <summary>
 /// Creates a new edge between source and target. The edge is not registered with the source and 
 /// target vertices unless it is added to the graph!
 /// </summary>
 /// <param name="a">The A vertex</param>
 /// <param name="b">The B vertex</param>
 /// <param name="graph">The graph to which this edge belongs</param>
 /// <param name="type">Whether to create an undirected or a directed edge</param>
 public Edge(Vertex a, Vertex b, Network graph, EdgeType type)
 {
     ID = Guid.NewGuid();
     A = a;
     B = b;
     Network = graph;
     EdgeType = type;
 }

 public SweepEvent(Point p, bool isLeft, PolygonType polygonType, SweepEvent otherSweepEvent, EdgeType edgeType)
 {
     this.p = p;
     this.isLeft = isLeft;
     this.polygonType = polygonType;
     this.otherSE = otherSweepEvent;
     this.edgeType = edgeType;
 }

 public Square(Point point, int size, Color surfaceColor, Color borderColor, EdgeType edgeType) : this()
 {
     this.Location = point;
     this.Size = size;
     this.SurfaceColor = surfaceColor;
     this.BorderColor = borderColor;
     this.EdgeType = edgeType;
 }

 internal void EnsureEdgeInfo(uint edgeId, uint startSlotId, uint endSlotId, EdgeType edgeType)
 {
     VisualEdge edge = controller.GetVisualEdge(edgeId);
     Assert.AreNotEqual(null, edge); // Make sure the edge exists.
     Assert.AreEqual(startSlotId, edge.StartSlotId); // Connecting from...
     Assert.AreEqual(endSlotId, edge.EndSlotId); // Connecting to...
     Assert.AreEqual(edgeType, edge.EdgeType); // Explicit or implicit?
 }

 public AbstractEdge(string name, long unid, bool showAnnotation, int weight, Position position, Transition transition, EdgeType edgeType)
     : base(name, unid, showAnnotation)
 {
     this.weight = weight;
     this.position = position;
     this.transition = transition;
     this.edgeType = edgeType;
 }

 /// <summary>
 /// Returns the edges in the graph of the type given, as set
 /// </summary>
 public static Dictionary<IEdge, SetValueType> Edges(IGraph graph, EdgeType edgeType, int threadId)
 {
     Dictionary<IEdge, SetValueType> edgesSet = new Dictionary<IEdge, SetValueType>();
     foreach(IEdge edge in graph.GetCompatibleEdges(edgeType))
     {
         edgesSet[edge] = null;
     }
     return edgesSet;
 }

        public PlanarGraphEdge(GeometryTutorLib.ConcreteAST.Point targ, EdgeType type, double c, int initDegree)
        {
            this.target = targ;
            edgeType = type;

            cost = c;
            degree = initDegree;
            isCycle = false;
        }

 public Stamp(String name, String seriesName, int issueYear, int width, int height, EdgeType type, int faceValue, double multiplier)
 {
     this.name = name;
     this.seriesName = seriesName;
     this.issueYear = issueYear;
     this.data = new StampData(width, height, type);
     this.faceValue = faceValue;
     this.multiplier = multiplier;
 }

        public Edge(Vertex start, Vertex end, EdgeType type)
        {
            Start = start;
            End = end;
            Type = type;

            Start.Add(this);
            End.Add(this);
        }

 internal VisualEdge(EdgeController edgeController, EdgeType edgeType)
 {
     this.edgeController = edgeController;
     this.EdgeType = edgeType;
     controlPoints.Add(new Point());
     controlPoints.Add(new Point());
     controlPoints.Add(new Point());
     controlPoints.Add(new Point());
 }

 private Point[] GetPoints(EdgeType type, int width, int height)
 {
     switch (type)
     {
         case EdgeType.Left: return Sweep(0, 0, 0, 1, height);
         case EdgeType.Top: return Sweep(0, 0, 1, 0, width);
         case EdgeType.Right: return Sweep(width - 1, 0, 0, 1, height);
         case EdgeType.Bottom: return Sweep(0, height - 1, 1, 0, width);
         default: throw new InvalidOperationException();
     }
 }

 public EdgeViewModel(NodeViewModel nVMEndA, NodeViewModel nVMEndB, EdgeType type)
 {
     edge = new Edge();
     NVMEndA = nVMEndA;
     NVMEndB = nVMEndB;
     MultA = "";
     MultB = "";
     Type = edgeTypeConverter(type);
     initArrow();
     newPath();
 }

 public Stamp[] getStamps(EdgeType type)
 {
     int numberOfStamps = this.count(type);
     Stamp[] result = new Stamp[numberOfStamps];
     int index = 0;
     for (int i = 0; i < this.index; i++)
     {
         if (this.stamps[i].Data.Type == type)
         {
             result[index++] = this.stamps[i];
         }
     }
     return result;
 }

        public void AddUndirectedEdge(Point from, Point to, double cost, EdgeType eType)
        {
            //
            // Are these nodes in the graph?
            //
            int fromNodeIndex = nodes.IndexOf(new PlanarGraphNode(from));
            int toNodeIndex = nodes.IndexOf(new PlanarGraphNode(to));

            if (fromNodeIndex == -1 || toNodeIndex == -1)
            {
                throw new ArgumentException("Edge uses undefined nodes: " + from + " " + to);
            }

            //
            // Check if the edge already exists
            //
            PlanarGraphEdge fromToEdge = nodes[fromNodeIndex].GetEdge(to);
            if (fromToEdge != null)
            {
                PlanarGraphEdge toFromEdge = nodes[toNodeIndex].GetEdge(from);

                fromToEdge.edgeType = UpdateEdge(fromToEdge.edgeType, eType);
                toFromEdge.edgeType = fromToEdge.edgeType;

                // Increment the degree if it is an arc.
                if (eType == EdgeType.REAL_ARC)
                {
                    fromToEdge.degree++;
                    toFromEdge.degree++;
                }
            }
            //
            // The edge does not exist.
            //
            else
            {
                nodes[fromNodeIndex].AddEdge(to, eType, cost, (eType == EdgeType.REAL_ARC ? 1 : 0));
                nodes[toNodeIndex].AddEdge(from, eType, cost, (eType == EdgeType.REAL_ARC ? 1 : 0));
            }
        }