コード例 #1
0
    /// <summary>
    /// Finds the coords. of the next item in the <see cref="PackedLayout"/> if it's
    /// added vertically.
    /// </summary>
    /// <param name="x">X coord. of previous node</param>
    /// <param name="y">Y coord. of previous node</param>
    /// <param name="verts">The list of all nodes</param>
    /// <param name="v">The index of the previous node in verts</param>
    /// <param name="newx">Returns the x coord. of the new node</param>
    /// <param name="newy">Returns the y coord. of the new node</param>
    /// <param name="dir">Whether the nodes are arranged Clockwise or Counterclockwise</param>
    /// <returns>true if a node can be added vertically and still be on the ellipse</returns>
    private bool nextv(double x, double y, CircularVertex[] verts, int v, out double newx, out double newy, CircularDirection dir) {
      newx = 0;
      newy = 0;
      bool inv = false; //true if it changes sides
      if (x >= 0 ^ dir == CircularDirection.Clockwise) {
        // y decreases
        newy = y - ((verts[v].Height + verts[v + 1].Height) / 2 + ESpacing);
        if (newy < -Yradius) {
          // y increases
          newy = y + ((verts[v].Height + verts[v + 1].Height) / 2 + ESpacing);
          if (newy > Yradius) { return false; }
          inv = true;
        }
      } else {
        // y increases
        newy = y + ((verts[v].Height + verts[v + 1].Height) / 2 + ESpacing);
        if (newy > Yradius) {
          // y decreases
          newy = y - ((verts[v].Height + verts[v + 1].Height) / 2 + ESpacing);
          if (newy < -Yradius) { return false; }
          inv = true;
        }
      }

      newx = Math.Sqrt(1 - newy * newy / (Yradius * Yradius)) * ERadius;
      if (x < 0 ^ inv) { newx = -newx; }
      if (Math.Abs(x - newx) > (verts[v].Width + verts[v + 1].Width) / 2) { return false; } else return true;
    }
コード例 #2
0
    private Random rand; // Packed layout sometimes alternates between 2 radii.  If this happens, a random value is added to stop the cycle.

    /// <summary>
    /// Finds the coords. of the next item in the <see cref="PackedLayout"/> if it's
    /// added horizontally.
    /// </summary>
    /// <param name="x">X coord. of previous node</param>
    /// <param name="y">Y coord. of previous node</param>
    /// <param name="verts">The list of all nodes</param>
    /// <param name="v">The index of the previous node in verts</param>
    /// <param name="newx">Returns the x coord. of the new node</param>
    /// <param name="newy">Returns the y coord. of the new node</param>
    /// <param name="dir">Whether the nodes are arranged Clockwise or Counterclockwise</param>
    /// <returns>true if a node can be added horizontally and still be on the ellipse</returns>
    private bool nexth(double x, double y, CircularVertex[] verts, int v, out double newx, out double newy, CircularDirection dir) {
      newx = 0;
      newy = 0;
      bool inv = false; //true if it changes sides
      if (y >= 0 ^ dir == CircularDirection.Clockwise) {
        // x increases
        newx = x + ((verts[v].Width + verts[v + 1].Width) / 2 + ESpacing);
        if (newx > ERadius) {
          // x decreases
          newx = x - ((verts[v].Width + verts[v + 1].Width) / 2 + ESpacing);
          if (newx < -ERadius) { return false; }
          inv = true;
        }
      } else {

        // x decreases
        newx = x - ((verts[v].Width + verts[v + 1].Width) / 2 + ESpacing);
        if (newx < -ERadius) {
          newx = x + ((verts[v].Width + verts[v + 1].Width) / 2 + ESpacing);
          if (newx > ERadius) { return false; }
          inv = true;
        }
      }

      newy = Math.Sqrt(1 - newx * newx / (ERadius * ERadius)) * Yradius;
      if (y < 0 ^ inv) { newy = -newy; }
      if (Math.Abs(y - newy) > (verts[v].Height + verts[v + 1].Height) / 2) { return false; } else return true;
    }
コード例 #3
0
 public Subset(CircularVertex n, List<Subset> gs) {
   List = new List<CircularVertex>(); Conns = new List<CircularVertex>();
   Head = n;
   List.Add(n);
   foreach (Subset g in gs) {
     foreach (CircularVertex nd in g.List) { this.List.Add(nd); }
   }
   foreach (CircularEdge li in n.SourceEdgesList) {
     CircularVertex nd = li.FromVertex;
     if (List.IndexOf(nd) < 0) { Conns.Add(nd); }
   }
   foreach (CircularEdge li in n.DestinationEdgesList) {
     CircularVertex nd = li.ToVertex;
     if (List.IndexOf(nd) < 0) { Conns.Add(nd); }
   }
 }
コード例 #4
0
    /// <summary>
    /// Sorts the nodes based on connectivity.  The oth node is the one with the highest
    /// connectivity, and each subsequent node it the one with the greatest number of links with nodes
    /// already in the list
    /// </summary>
    /// <param name="l">The nodes to sort</param>
    /// <returns>The sorted list</returns>
    /// <remarks>This is used for cross reduction before <see cref="Optimize"/> is called because
    /// it makes the cross reduction much more effective.
    /// </remarks>
    private List<CircularVertex> ConnectivityArrange(CircularVertex[] l) {
      int[] conns = new int[l.Length];
      List<CircularVertex> res = new List<CircularVertex>();
      for (int i = 0; i < l.Length; i++) {
        int maxconn = -1;
        int maxind = -1;
        if (i == 0) {
          for (int j = 0; j < l.Length; j++) {
            CircularVertex vtx = l[j];
            int nconn = vtx.SourceEdgesCount + vtx.DestinationEdgesCount;
            if (nconn > maxconn) {
              maxconn = nconn;
              maxind = j;
            }
          }
        } else for (int j = 0; j < l.Length; j++) {
            int nconn = conns[j];
            if (nconn > maxconn) {
              maxconn = nconn;
              maxind = j;
            }
          }
        res.Add(l[maxind]);
        conns[maxind] = -1;

        CircularVertex v = l[maxind];
        foreach (CircularEdge li in v.SourceEdgesList) {
          CircularVertex f = li.FromVertex;
          int ind = Array.IndexOf(l, f);
          if (ind < 0) { continue; }
          if (conns[ind] >= 0) { conns[ind]++; }
        }
        foreach (CircularEdge li in v.DestinationEdgesList) {
          CircularVertex f = li.ToVertex;
          int ind = Array.IndexOf(l, f);
          if (ind < 0) { continue; }
          if (conns[ind] >= 0) { conns[ind]++; }
        }
      }
      return res;
    }
コード例 #5
0
 /// <summary>
 /// Sorts the vertexes based on whatever <see cref="Sorting"/> specifies.
 /// </summary>
 /// <param name="vertexes">The vertexes to sort</param>
 private List<CircularVertex> Sort(CircularVertex[] vertexes) {
   switch (Sorting) {
     case CircularSorting.Forwards: break;
     case CircularSorting.Reverse: Array.Reverse(vertexes, 0, vertexes.Length); break;
     case CircularSorting.Ascending: if (Comparer != null) { Array.Sort(vertexes, Comparer); } break;
     case CircularSorting.Descending: if (Comparer != null) { Array.Sort(vertexes, Comparer); }
       Array.Reverse(vertexes, 0, vertexes.Length); break;
     case CircularSorting.Optimized: return Optimize(ConnectivityArrange(vertexes));
     //case CircularSorting.GroupedOptimized: return OptimizeGroup(ConnectivityArrange(new List<CircularVertex>(nodes)));
     default: throw new NotImplementedException("This CircularSorting is not yet implemented");
   }
   return new List<CircularVertex>(vertexes);
 }
コード例 #6
0
 /// <summary>
 /// Compares a new gap with the current one.  If it's better, it updates <see cref="gap"/>, <see cref="xcoords"/>,and <see cref="ycoords"/>.
 /// This is for a partial sweep, where overshooting (gap less than 0) is no worse than undershooting (gap > 0).
 /// </summary>
 /// <param name="gap"></param>
 /// <param name="verts"></param>
 public void compare2(double gap, CircularVertex[] verts) {
   if (Math.Abs(gap) < Math.Abs(this.gap)) {
     this.gap = gap;
     xcoords = new double[verts.Length];
     ycoords = new double[verts.Length];
     for (int i = 0; i < verts.Length; i++) {
       xcoords[i] = verts[i].Position.X;
       ycoords[i] = verts[i].Position.Y;
     }
   }
 }