public Rectangle DrawEdge(IDeviceContext dc, Rectangle bounds, Edges edges, EdgeStyle style, EdgeEffects effects)
{
if (dc == null)
{
throw new ArgumentNullException("dc");
}
if (!System.Windows.Forms.ClientUtils.IsEnumValid_Masked(edges, (int) edges, 0x1f))
{
throw new InvalidEnumArgumentException("edges", (int) edges, typeof(Edges));
}
if (!System.Windows.Forms.ClientUtils.IsEnumValid_NotSequential(style, (int) style, new int[] { 5, 10, 6, 9 }))
{
throw new InvalidEnumArgumentException("style", (int) style, typeof(EdgeStyle));
}
if (!System.Windows.Forms.ClientUtils.IsEnumValid_Masked(effects, (int) effects, 0xd800))
{
throw new InvalidEnumArgumentException("effects", (int) effects, typeof(EdgeEffects));
}
System.Windows.Forms.NativeMethods.COMRECT pContentRect = new System.Windows.Forms.NativeMethods.COMRECT();
using (WindowsGraphicsWrapper wrapper = new WindowsGraphicsWrapper(dc, TextFormatFlags.PreserveGraphicsTranslateTransform | TextFormatFlags.PreserveGraphicsClipping))
{
HandleRef hdc = new HandleRef(wrapper, wrapper.WindowsGraphics.DeviceContext.Hdc);
this.lastHResult = System.Windows.Forms.SafeNativeMethods.DrawThemeEdge(new HandleRef(this, this.Handle), hdc, this.part, this.state, new System.Windows.Forms.NativeMethods.COMRECT(bounds), (int) style, ((int) (edges | ((Edges) ((int) effects)))) | 0x2000, pContentRect);
}
return Rectangle.FromLTRB(pContentRect.left, pContentRect.top, pContentRect.right, pContentRect.bottom);
}
public void CreateEdges()
{
setParams();
if (edges != null)
edges.Clear();
edges = new Edges(EdgeEntity, edgeCount, size);
}
public Square(Point location, int size, Color surfaceColor, Color borderColor,Edges edges)
{
this.Location = location;
this.Size = size;
this.SurfaceColor = surfaceColor;
this.BorderColor = borderColor;
this.Edges = edges;
}
public int UxThemeDrawThemeEdge (IntPtr hTheme, IDeviceContext dc, int iPartId, int iStateId, Rectangle bounds, Edges edges, EdgeStyle style, EdgeEffects effects, out Rectangle result)
{
XplatUIWin32.RECT BoundsRect = XplatUIWin32.RECT.FromRectangle (bounds);
XplatUIWin32.RECT retval;
int hresult = UXTheme.DrawThemeEdge (hTheme, dc.GetHdc (), iPartId, iStateId, ref BoundsRect, (uint)style, (uint)edges + (uint)effects, out retval);
dc.ReleaseHdc ();
result = retval.ToRectangle();
return hresult;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Ensure that the passed in edge is adjacent to this vertex. </summary>
/// <remarks> Darrellp, 2/18/2011. </remarks>
/// <param name="edge"> Edge to check. </param>
/// <returns> True if the edge is adjacent, else false. </returns>
////////////////////////////////////////////////////////////////////////////////////////////////////
internal bool FValidateEdgeIsAdjacent(WeEdge edge)
{
return(Edges.Any(edgeCur => ReferenceEquals(edgeCur, edge)));
}
/// <summary>
/// Iterator access to the ordered list of edges is optimized by
/// copying the map collection to a list. (This assumes that
/// once an iterator is requested, it is likely that insertion into
/// the map is complete).
/// </summary>
public IEnumerator <EdgeEnd> GetEnumerator()
{
return(Edges.GetEnumerator());
}
public override string ToString()
{
return($"Nodes: {Nodes.ToString()}\n\nEdges: {Edges.ToString()}\n");
}
public void ReadEdges(byte[] memory)
{
TreeNode res = new TreeNode("Edges list, start: 0x" + readerpos.ToString("X4"));
UnknownList edges = new UnknownList(); //here using struct unknown list, later we're just filling up data array byte by byte
Edges e = new Edges();
edges.size = BitConverter.ToInt32(memory, readerpos);
edges.count = BitConverter.ToInt32(memory, readerpos + 4);
e.size = edges.size;
e.count = edges.count;
//quick'n'dirty fix above, need work! <--------------
readerpos += 8;
int len = edges.size * edges.count;
edges.data = new byte[len];
res.Nodes.Add(new TreeNode("Size : " + edges.size.ToString()));
res.Nodes.Add(new TreeNode("Count : " + edges.count.ToString()));
TreeNode data = new TreeNode("Data");
int datacounter = 0;
e.UVSet = new List<UVSet>();
for (int i = 0; i < edges.count; i++)
{
UVSet uv = new UVSet();
uv.UVs = new List<Vector2>();
//here adding packed normals
uv.x1 = memory[readerpos];
uv.y1 = memory[readerpos + 1];
uv.z1 = memory[readerpos + 2];
uv.w1 = memory[readerpos + 3];
uv.x2 = memory[readerpos + 4];
uv.y2 = memory[readerpos + 5];
uv.z2 = memory[readerpos + 6];
uv.w2 = memory[readerpos + 7];
//string rawdata = "";
//string n1 = packedNorm(readerpos);
//string n2 = packedNorm(readerpos + 4);
//rawdata = n1 + " " + n2 + " UV Sets: "; //
// memory[readerpos].ToString("X2") + " " +
// memory[readerpos + 1].ToString("X2") + " " +
// memory[readerpos + 2].ToString("X2") + " " +
// memory[readerpos + 3].ToString("X2") + " " +
// memory[readerpos + 4].ToString("X2") + " " +
// memory[readerpos + 5].ToString("X2") + " " +
// memory[readerpos + 6].ToString("X2") + " " +
// memory[readerpos + 7].ToString("X2") + " " +
readerpos += 8;
for (int row = 0; row < (edges.size - 8) / 4; row++)
{
float u = HalfToFloat(BitConverter.ToUInt16(memory, readerpos));
float v = HalfToFloat(BitConverter.ToUInt16(memory, readerpos + 2));
uv.UVs.Add(new Vector2(u, v));
//rawdata += "uv(" + u + " ; " + v + ") ";
edges.data[datacounter] = memory[readerpos];
readerpos += 4;
datacounter += 1;
}
e.UVSet.Add(uv);
data.Nodes.Add(new TreeNode(i.ToString("d4") + ": " ));
}
res.Nodes.Add(data);
e.t = res;
Mesh.Edges = e;
}
public int UxThemeDrawThemeEdge (IntPtr hTheme, IDeviceContext dc, int iPartId, int iStateId, Rectangle bounds, Edges edges, EdgeStyle style, EdgeEffects effects, out Rectangle result)
{
result = Rectangle.Empty;
return (int)S.S_FALSE;
}
/// <summary>
/// Add all the effects of "af" over the given variable
/// </summary>
/// <param name="af"></param>
/// <param name="variableEffects"></param>
/// <param name="tree"></param>
/// <param name="p"></param>
private void CheckAndAddEffect(AField af, Set<VariableEffect> variableEffects, Edges tree, Variable p)
{
IPTAnalysisNode from = this.Address(p);
// Compute all paths from the variable to the affected node
// DIEGO-TODO: this is terribly slow. I have to make it much more faster.
IEnumerable<IEnumerable<Edge>> paths = PointsToGraph.DFSPathFromTo(from, af.Src, tree);
foreach (List<Edge> currentPath in paths)
{
IPTAnalysisNode rootNode = null;
if (currentPath.Count > 0)
rootNode = currentPath[0].Src;
else
rootNode = af.Src;
if (rootNode.IsVariableReference)
{
IVarRefNode vrNode = rootNode as IVarRefNode;
Variable v = vrNode.ReferencedVariable;
if (v != null)
{
VariableEffect vEffect = ComputeOneEffectPath(af, currentPath, v);
variableEffects.Add(vEffect);
}
}
}
}
internal EdgeEnumerator1(Edges linksAtVertex)
{
links=linksAtVertex;
ntag=node-links.graph.n;
cur=-1;
}
// todo: not cut by rhythm
// todo: i forget math
private SliderTick[] GetPerfectDiscreteBallData(double interval)
{
if (Math.Round(interval - _singleElapsedTime) >= 0)
{
return(Array.Empty <SliderTick>());
}
Vector2 <float> p1;
Vector2 <float> p2;
Vector2 <float> p3;
try
{
p1 = StartPoint;
p2 = CurvePoints[0];
p3 = CurvePoints[1];
}
catch (IndexOutOfRangeException)
{
this.SliderType = SliderType.Linear;
return(GetBezierDiscreteBallData(interval));
}
var circle = GetCircle(p1, p2, p3);
var radStart = Math.Atan2(p1.Y - circle.p.Y, p1.X - circle.p.X);
var radMid = Math.Atan2(p2.Y - circle.p.Y, p2.X - circle.p.X);
var radEnd = Math.Atan2(p3.Y - circle.p.Y, p3.X - circle.p.X);
if (radMid - radStart > Math.PI)
{
radMid -= Math.PI * 2;
}
else if (radMid - radStart < -Math.PI)
{
radMid += Math.PI * 2;
}
if (radEnd - radMid > Math.PI)
{
radEnd -= Math.PI * 2;
}
else if (radEnd - radMid < -Math.PI)
{
radEnd += Math.PI * 2;
}
var ticks = new List <SliderTick>();
for (int i = 1; i *interval < _singleElapsedTime; i++)
{
var offset = i * interval; // 当前tick的相对时间
if (Edges.Any(k => Math.Abs(k.Offset - _offset - offset) < 0.01))
{
continue;
}
var ratio = offset / _singleElapsedTime; // 相对整个滑条的时间比例，=距离比例
var relativeRad = (radEnd - radStart) * ratio; // 至滑条头的距离
var offsetRad = radStart + relativeRad;
var x = circle.p.X + circle.r * Math.Cos(offsetRad);
var y = circle.p.Y + circle.r * Math.Sin(offsetRad);
ticks.Add(new SliderTick(_offset + offset, new Vector2 <float>((float)x, (float)y)));
}
if (Repeat > 1)
{
var firstSingleCopy = ticks.ToArray();
for (int i = 2; i <= Repeat; i++)
{
var reverse = i % 2 == 0;
if (reverse)
{
ticks.AddRange(firstSingleCopy.Reverse().Select(k =>
new SliderTick((_singleElapsedTime - (k.Offset - _offset)) + (i - 1) * _singleElapsedTime + _offset,
k.Point)));
}
else
{
ticks.AddRange(firstSingleCopy.Select(k =>
new SliderTick(k.Offset + (i - 1) * _singleElapsedTime, k.Point)));
}
}
}
return(ticks.ToArray());
//var degStart = radStart / Math.PI * 180;
//var degMid = radMid / Math.PI * 180;
//var degEnd = radEnd / Math.PI * 180;
//return Array.Empty<SliderTick>();
}
public static void InitMap()
{
vertexes = new Vertexes();
edges = new Edges();
}
public void RemoveEdge(Edge edge)
{
//TODO Do I need to do anything else here?
Edges.Remove(edge);
}
IEnumerator IEnumerable.GetEnumerator()
{
return(Edges.GetEnumerator());
}
/// <summary>
/// Adiciona um arco com nó origem igual ao nó atual, e destino e custo de acordo com os parâmetros.
/// </summary>
/// <param name="to">O nó destino.</param>
/// <param name="cost">O custo associado ao arco.</param>
public void AddEdge(Node to, int cost)
{
Edges.Add(new Edge(this, to, cost));
}
public void CleanNullRefs()
{
VerticesData.RemoveWhere(pair => Util.IsBadRef(pair.Key));
Edges.RemoveWhere(edge => Util.IsBadRef(edge.Source) || Util.IsBadRef(edge.Target));
}
/// <summary>
/// Calculates the desired position, rotation and snapping edge given the position of the window.
/// </summary>
/// <param name="startx"></param>
/// <param name="starty"></param>
/// <param name="angle"></param>
/// <param name="edge"></param>
/// <returns></returns>
private DoublePoint GetDesiredPosition(double startx, double starty, out double angle, out Edges edge)
{
angle = 0d;
edge = Edges.None;
if (WindowEdgeSnapBehavior == WindowEdgeSnapBehavior.None)
{
_lastWindowPosition.X = startx;
_lastWindowPosition.Y = starty;
}
var movableAreaBoundaries = this.GetMovableArea();
if (WindowEdgeSnapBehavior == WindowEdgeSnapBehavior.Straight ||
WindowEdgeSnapBehavior == WindowEdgeSnapBehavior.StraightToTitleBar)
{
var x = startx.Max(movableAreaBoundaries.Left).Min(movableAreaBoundaries.Right);
var y = starty.Max(movableAreaBoundaries.Top).Min(movableAreaBoundaries.Bottom);
DoublePoint ret;
ret.X = x;
ret.Y = y;
return ret;
}
else// if (WindowEdgeSnapBehavior == WindowEdgeSnapBehavior.ToTitleBarWithRotation)
{
var x = startx.Max(movableAreaBoundaries.Left).Min(movableAreaBoundaries.Right);
var y = starty.Max(movableAreaBoundaries.Top).Min(movableAreaBoundaries.Bottom);
if (x != startx || y != starty)
{
// title height
var t = _titleGrid == null ? 0 : _titleGrid.ActualHeight + (_border == null ? 0 : _border.BorderThickness.Top);
var h = this.ActualHeight;
var w = this.ActualWidth;
if (x != startx && (y == starty || x.Distance(startx) > y.Distance(starty)))
{
if (startx < x)
{
edge = Edges.Left;
x += t - w / 2 - h / 2;
angle = 90;
}
else
{
edge = Edges.Right;
x -= t - w / 2 - h / 2;
angle = -90;
}
var minY = movableAreaBoundaries.Top + this.ActualWidth / 2 - this.ActualHeight / 2;
var maxY = movableAreaBoundaries.Bottom - this.ActualWidth / 2 + this.ActualHeight / 2;
y = starty.Max(minY).Min(maxY);
}
else if (y != starty && (x == startx || y.Distance(starty) > x.Distance(startx)))
{
if (starty < y)
{
edge = Edges.Top;
angle = 180;
y += t - h;
}
else
{
edge = Edges.Bottom;
angle = 0;
y -= t - h;
}
}
}
DoublePoint ret;
ret.X = x;
ret.Y = y;
return ret;
}
}
public void Clear()
{
edges = new Edges();
}
public System.Drawing.Rectangle DrawEdge(System.Drawing.IDeviceContext dc, System.Drawing.Rectangle bounds, Edges edges, EdgeStyle style, EdgeEffects effects)
{
}
/// <summary>
/// Iterator access to the ordered list of edges is optimized by
/// copying the map collection to a list. (This assumes that
/// once an iterator is requested, it is likely that insertion into
/// the map is complete).
/// </summary>
public IEnumerator GetEnumerator()
{
return(Edges.GetEnumerator());
}
Sprite GetSprite(Sprite[] sprites, Edges edges, int variant)
{
if (edges == Edges.None)
return null;
return sprites[variant * variantStride + edgesToSpriteIndexOffset[(byte)edges]];
}
private void btnMonitor_Click(object sender, EventArgs e)
{
var test = new Edges(lstLog);
test.GetListOfEdge();
}
public Rectangle DrawEdge (IDeviceContext dc, Rectangle bounds, Edges edges, EdgeStyle style, EdgeEffects effects)
{
if (dc == null)
throw new ArgumentNullException ("dc");
Rectangle result;
last_hresult = VisualStyles.UxThemeDrawThemeEdge (theme, dc, this.part, this.state, bounds, edges, style, effects, out result);
return result;
}
private void FortunesAlgorithm()
{
Profiler.BeginSample("DAll HEs");
Halfedge.DisposeAll();
Edge.DisposeAll();
Profiler.EndSample();
//UnityEngine.Debug.Log("HE pool: " + Halfedge.unusedPool.Count);
currentSiteIndex = 0;
nVertices = 0;
// vars
Profiler.BeginSample("Fortunes: initing");
Site newSite, bottomSite, topSite, tempSite;
Vertex v, vertex;
Vector2f newIntStar = Vector2f.zero;
bool leftRight;
Halfedge lbnd = null;
Halfedge rbnd = null;
Halfedge llbnd = null;
Halfedge rrbnd = null;
Halfedge bisector = null;
Edge edge;
Profiler.EndSample();
// Data bounds
Profiler.BeginSample("Fortunes: Getting data bounds");
Rectf dataBounds = Site.GetSitesBounds(sites);
Profiler.EndSample();
int sqrtSitesNb = (int)Math.Sqrt(sites.Count + 4); // WTF
Profiler.BeginSample("Fortunes: Init heap");
if (heap == null)
{
heap = new HalfedgePriorityQueue(dataBounds.y, dataBounds.height, sqrtSitesNb);
}
else
{
heap.ReinitNoSizeChange(dataBounds.y, dataBounds.height);
}
Profiler.EndSample();
Profiler.BeginSample("Fortunes: Init EdgeList");
if (edgeList == null)
{
edgeList = new EdgeList(dataBounds.x, dataBounds.width, sqrtSitesNb);
}
else
{
edgeList.ClearNoResize(dataBounds.x, dataBounds.width);
}
//edgeList = new EdgeList(dataBounds.x, dataBounds.width, sqrtSitesNb);
Profiler.EndSample();
Profiler.BeginSample("Fortunes: Init HEs and vertices");
if (halfEdges == null) // TODO: Move to init
{
halfEdges = new List <Halfedge>();
vertices = new List <Vertex>();
}
else
{
halfEdges.Clear();
vertices.Clear();
}
Profiler.EndSample();
Site bottomMostSite = GetNextSite();
newSite = GetNextSite();
Profiler.BeginSample("Fortunes: Main Loop");
while (true)
{
if (heap.count > 0)
{
newIntStar = heap.Min();
}
if (newSite != null &&
(heap.count == 0 || CompareByYThenX(newSite, newIntStar) < 0))
{
// New site is smallest
//Debug.Log("smallest: new site " + newSite);
// Step 8:
// The halfedge just to the left of newSite
//UnityEngine.Debug.Log("lbnd: " + lbnd);
lbnd = edgeList.EdgeListLeftNeighbor(newSite.Coord);
// The halfedge just to the right
rbnd = lbnd.edgeListRightNeighbor;
//UnityEngine.Debug.Log("rbnd: " + rbnd);
// This is the same as leftRegion(rbnd)
// This Site determines the region containing the new site
bottomSite = RightRegion(lbnd, bottomMostSite);
//UnityEngine.Debug.Log("new Site is in region of existing site: " + bottomSite);
// Step 9
Profiler.BeginSample("CreateBisectingEdge");
edge = Edge.CreateBisectingEdge(bottomSite, newSite);
Profiler.EndSample();
//UnityEngine.Debug.Log("new edge: " + edge);
Edges.Add(edge);
bisector = Halfedge.Create(edge, false);
halfEdges.Add(bisector);
// Inserting two halfedges into edgelist constitutes Step 10:
// Insert bisector to the right of lbnd:
edgeList.Insert(lbnd, bisector);
// First half of Step 11:
if ((vertex = Vertex.Intersect(lbnd, bisector)) != null)
{
vertices.Add(vertex);
heap.Remove(lbnd);
lbnd.vertex = vertex;
lbnd.ystar = vertex.y + newSite.Dist(vertex);
heap.Insert(lbnd);
}
lbnd = bisector;
bisector = Halfedge.Create(edge, true);
halfEdges.Add(bisector);
// Second halfedge for Step 10::
// Insert bisector to the right of lbnd:
edgeList.Insert(lbnd, bisector);
// Second half of Step 11:
if ((vertex = Vertex.Intersect(bisector, rbnd)) != null)
{
vertices.Add(vertex);
bisector.vertex = vertex;
bisector.ystar = vertex.y + newSite.Dist(vertex);
heap.Insert(bisector);
}
newSite = GetNextSite();
}
else if (heap.count > 0)
{
// Intersection is smallest
lbnd = heap.ExtractMin();
llbnd = lbnd.edgeListLeftNeighbor;
rbnd = lbnd.edgeListRightNeighbor;
rrbnd = rbnd.edgeListRightNeighbor;
bottomSite = LeftRegion(lbnd, bottomMostSite);
topSite = RightRegion(rbnd, bottomMostSite);
// These three sites define a Delaunay triangle
// (not actually using these for anything...)
#if TRIANGLES
triangles.Add(new Triangle(bottomSite, topSite, RightRegion(lbnd, bottomMostSite)));
#endif
v = lbnd.vertex;
v.VertexIndex = nVertices++;
lbnd.edge.SetVertex(lbnd.leftRight, v);
rbnd.edge.SetVertex(rbnd.leftRight, v);
edgeList.Remove(lbnd);
heap.Remove(rbnd);
edgeList.Remove(rbnd);
leftRight = false;
if (bottomSite.y > topSite.y)
{
tempSite = bottomSite;
bottomSite = topSite;
topSite = tempSite;
leftRight = true;
}
edge = Edge.CreateBisectingEdge(bottomSite, topSite);
Profiler.BeginSample("addedge");
Edges.Add(edge);
Profiler.EndSample();
bisector = Halfedge.Create(edge, leftRight);
halfEdges.Add(bisector);
edgeList.Insert(llbnd, bisector);
edge.SetVertex(!leftRight, v);
if ((vertex = Vertex.Intersect(llbnd, bisector)) != null)
{
vertices.Add(vertex);
heap.Remove(llbnd);
llbnd.vertex = vertex;
llbnd.ystar = vertex.y + bottomSite.Dist(vertex);
heap.Insert(llbnd);
}
if ((vertex = Vertex.Intersect(bisector, rrbnd)) != null)
{
vertices.Add(vertex);
bisector.vertex = vertex;
bisector.ystar = vertex.y + bottomSite.Dist(vertex);
heap.Insert(bisector);
}
}
else
{
break;
}
}
Profiler.EndSample();
// DISPOSE
// Heap should be empty now
Profiler.BeginSample("Fortunes: Heap dispose");
heap.Dispose();
Profiler.EndSample();
Profiler.BeginSample("Fortunes: Edgelist dispose");
edgeList.Dispose();
Profiler.EndSample();
Profiler.BeginSample("Fortunes: Halfedges REALLY dispose");
for (int i = 0; i < halfEdges.Count; i++)
{
halfEdges[i].ReallyDispose();
}
halfEdges.Clear();
Profiler.EndSample();
Profiler.BeginSample("Fortunes: ClipVertices");
// we need the vertices to clip the edges
for (int i = 0; i < Edges.Count; i++)
{
Edges[i].ClipVertices(PlotBounds, true);
}
Profiler.EndSample();
// But we don't actually ever use them again!
if (!disposeVerticesManually)
{
Profiler.BeginSample("Vertices dispose");
DisposeVertices();
Profiler.EndSample();
UnityEngine.Debug.Log("Disposing vertices!");
}
/*
* UnityEngine.Debug.Assert(Halfedge.unusedPool.Contains(lbnd), "lbnd");
* UnityEngine.Debug.Assert(Halfedge.unusedPool.Contains(rbnd), "rbnd");
* UnityEngine.Debug.Assert(Halfedge.unusedPool.Contains(llbnd), "llbnd");
* UnityEngine.Debug.Assert(Halfedge.unusedPool.Contains(rrbnd), "rrbnd");
* UnityEngine.Debug.Assert(Halfedge.unusedPool.Contains(bisector), "bisector");
*/
}
public bool ContainsEdge(Relation <T, P> relation)
{
return(Edges.Contains(relation));
}
Sprite GetTile(Sprite[] sprites, Edges edges, int variant)
{
if (edges == Edges.None)
return null;
return sprites[variant * variantStride + spriteMap[(byte)edges]];
}
public ShroudRenderer(World world, ShroudRendererInfo info)
{
if (info.ShroudVariants.Length != info.FogVariants.Length)
{
throw new ArgumentException("ShroudRenderer must define the same number of shroud and fog variants!");
}
if ((info.OverrideFullFog == null) ^ (info.OverrideFullShroud == null))
{
throw new ArgumentException("ShroudRenderer cannot define overrides for only one of shroud or fog!");
}
if (info.ShroudVariants.Length > byte.MaxValue)
{
throw new ArgumentException("ShroudRenderer cannot define this many shroud and fog variants.");
}
if (info.Index.Length >= byte.MaxValue)
{
throw new ArgumentException("ShroudRenderer cannot define this many indexes for shroud directions.");
}
this.info = info;
this.map = world.Map;
tileInfos = new CellLayer <TileInfo>(map);
//Load sprite variants
var variantCount = info.ShroudVariants.Length;
variantStride = (byte)(info.Index.Length + (info.OverrideFullShroud != null ? 1 : 0));
shroudSprites = new Sprite[variantCount * variantStride];
fogSprites = new Sprite[variantCount * variantStride];
var sequenceProvider = map.Rules.Sequences;
for (var j = 0; j < variantCount; j++)
{
var shroud = sequenceProvider.GetSequence(info.Sequence, info.ShroudVariants[j]);
var fog = sequenceProvider.GetSequence(info.Sequence, info.FogVariants[j]);
for (var i = 0; i < info.Index.Length; i++)
{
shroudSprites[j * variantStride + i] = shroud.GetSprite(i);
fogSprites[j * variantStride + i] = fog.GetSprite(i);
}
if (info.OverrideFullShroud != null)
{
var i = (j + 1) * variantStride - 1;
shroudSprites[i] = sequenceProvider.GetSequence(info.Sequence, info.OverrideFullShroud).GetSprite(0);
fogSprites[i] = sequenceProvider.GetSequence(info.Sequence, info.OverrideFullFog).GetSprite(0);
}
}
//Mapping of shrouded directions -> sprite index
edgesToSpriteIndexOffset = new byte[(byte)(info.UseExtendedIndex ? Edges.All : Edges.AllCorners) + 1];
for (var i = 0; i < info.Index.Length; i++)
{
edgesToSpriteIndexOffset[info.Index[i]] = (byte)i;
}
if (info.OverrideFullShroud != null)
{
edgesToSpriteIndexOffset[info.OverrideShroudIndex] = (byte)(variantStride - 1);
}
notVisibleEdges = info.UseExtendedIndex ? Edges.AllSides : Edges.AllCorners;
}
public Edge <T> FindEdge(Node <T> node1, Node <T> node2)
{
return(Edges.Where(x => (x.Node1 == node1) && (x.Node2 == node2)).FirstOrDefault() ?? Edges.Where(x => (x.Node1 == node2) && (x.Node2 == node1)).FirstOrDefault());
}
public static Bitmap DetectEdges(Bitmap image)
{
Edges edgeDetector = new Edges();
return(edgeDetector.Apply(image));
}
//parse from a xml file generated by a different project
private void FromXML()
{
XmlDocument doc = new XmlDocument();
doc.Load("database.xml");
XmlNode root = doc.DocumentElement;
XmlNode treverse = root.FirstChild;
Dictionary <int, String> NameD = new Dictionary <int, String>();
Dictionary <int, String> PathD = new Dictionary <int, String>();
while (treverse != null)
{
int key = -1;
String v = "";
String d = "";
foreach (XmlNode node in treverse.ChildNodes)
{
switch (node.Name)
{
case "Key":
key = int.Parse(node.InnerText);
Console.WriteLine("Detect vertex: " + key);
break;
case "Value":
v = node.InnerText;
Console.WriteLine("Detect value: " + v);
break;
case "Description":
d = node.InnerText;
Console.WriteLine("Detect description: " + d);
break;
}
}
GS.AddParticle(key);
NameD.Add(key, v.Substring(1));
PathD.Add(key, d.Substring(1));
foreach (XmlNode collection in treverse.ChildNodes)
{
switch (collection.Name)
{
case "ChildCollection":
foreach (int n in Retrive(collection.InnerText))
{
GS.AddEdge(key, n);
Console.WriteLine("Detect edge: " + key + "->" + n);
}
break;
case "ParentCollection":
foreach (int n in Retrive(collection.InnerText))
{
GS.AddEdge(n, key);
Console.WriteLine("Detect edge: " + n + "->" + key);
}
break;
}
}
treverse = treverse.NextSibling;
}
var od = new Dictionary <int, int>();
for (int i = 0; i < GS.V.Count; i++)
{
od.Add(GS.V[i], i);
}
foreach (var ve in GS.V)
{
Color c = SimpleColor(od[ve]).Color;
foreach (var item in od)
{
if (FromSamePackage(NameD[ve], NameD[item.Key]))
{
c = SimpleColor(od[item.Value]).Color;
}
}
Vertices.Add(new MassParticleViewModel(ve, c, NameD[ve] + "Path: " + PathD[ve], 450, 800));
}
foreach (var ed in GS.E)
{
Edges.Add(new EdgeViewModel(ed.Item1, ed.Item2, Color.FromRgb(125, 125, 125), 450, 800));
}
}
private Edges DetectEdges(byte* data, int width, int height, byte edgeColor, float threshold)
{
data = InterpolateEdges(data, ref width, ref height, edgeColor);
Edges edges = new Edges(width, height);
int maxSide = Math.Max(width, height) - 1;
for (int i = 1; i < maxSide; i++)
{
int edgeColorsHorz = 0, edgeColorsVert = 0;
for (int j = 1; j < maxSide; j++)
{
DetectEdge(data, i, j, width, height, edgeColor, ref edgeColorsHorz);
DetectEdge(data, j, i, height, width, edgeColor, ref edgeColorsVert);
}
StoreEdge(edgeColorsHorz, i, width, threshold, edges.Horz);
StoreEdge(edgeColorsVert, i, height, threshold, edges.Vert);
}
edges.CompleteBorderEdges();
return edges;
}
/// <summary>
/// Удаление ребра
/// </summary>
/// <param name="e">ребро</param>
public void DeleteEdge(Edge e)
{
Edges.Remove(e);
}
private void OnBorderManipulationInertiaStarting(object sender, ManipulationInertiaStartingRoutedEventArgs e)
{
_flickStartX = this.X;
_flickStartY = this.Y;
_flickStartCumulativeX = e.Cumulative.Translation.X;
_flickStartCumulativeY = e.Cumulative.Translation.Y;
if (_isDraggingFromSnapped)
{
// TODO: Prevent snapping if flicking towards center of screen
}
if (_layoutGridTransform != null)
{
_flickStartAngle = _layoutGridTransform.Rotation;
}
var naturalFlickDisplacement = e.GetExpectedDisplacement();
e.TranslationBehavior.DesiredDisplacement = naturalFlickDisplacement;
_naturalFlickDisplacementX = e.GetExpectedDisplacementX();
_naturalFlickDisplacementY = e.GetExpectedDisplacementY();
Edges desiredSnapEdge;
var desiredPosition = this.GetDesiredPosition(_flickStartX + _naturalFlickDisplacementX, _flickStartY + _naturalFlickDisplacementY, out _flickAdjustedEndAngle, out desiredSnapEdge);
_flickAdjustedEndX = desiredPosition.X;
_flickAdjustedEndY = desiredPosition.Y;
if (desiredSnapEdge == Edges.None)
{
return;
}
_lastSnapEdge = desiredSnapEdge;
_isAdjustedFlick = true;
if (_flickAdjustedEndX != _naturalFlickDisplacementX && (_flickAdjustedEndY == _naturalFlickDisplacementY ||
_flickAdjustedEndX.Distance(_naturalFlickDisplacementX) > _flickAdjustedEndY.Distance(_naturalFlickDisplacementY)))
{
// snap to left or right side
e.SetDesiredDisplacementX(_flickAdjustedEndX - _flickStartX);
_naturalFlickDisplacementX = e.GetExpectedDisplacementX();
_naturalFlickDisplacementY = e.GetExpectedDisplacementY();
}
else if (_flickAdjustedEndY != _naturalFlickDisplacementY && (_flickAdjustedEndX == _naturalFlickDisplacementX ||
_flickAdjustedEndX.Distance(_naturalFlickDisplacementY) > _flickAdjustedEndY.Distance(_naturalFlickDisplacementX)))
{
// snap to left or right side
e.SetDesiredDisplacementY(_flickAdjustedEndY - _flickStartY);
_naturalFlickDisplacementX = e.GetExpectedDisplacementX();
_naturalFlickDisplacementY = e.GetExpectedDisplacementY();
}
if (e.GetExpectedDisplacementDuration() > 0.5)
{
_isFlickTooLong = true;
_restorePositionOnStateChange = false;
this.WindowState = WindowStates.Snapped;
_restorePositionOnStateChange = true;
if (WindowEdgeSnapBehavior != WindowEdgeSnapBehavior.ToTitleBarWithRotation)
{
#pragma warning disable 4014
AnimateStraightSnapAsync(_flickAdjustedEndX, _flickAdjustedEndY);
#pragma warning restore 4014
}
else
{
#pragma warning disable 4014
AnimateRotatedSnapAsync(_flickAdjustedEndX, _flickAdjustedEndY, _flickAdjustedEndAngle);
#pragma warning restore 4014
}
}
}
/// <summary>
/// Retrun the degree value of the specific node ID on the network topology.
/// </summary>
/// <param name="NodeID">The node ID on the network topology.</param>
/// <returns>The degree value for the node ID on the network topology.</returns>
public int Degree(int NodeID)
{
return(Edges.Where(n => n.Node1 == NodeID || n.Node2 == NodeID).ToList().Count);
}
internal EdgeEnumerator0(Edges linksAtVertex)
{
links=linksAtVertex;
cur=-1;
}
public void CreateEdge(int Id, int Start, int End, int SizeModule, int NumberModules, int CostModule)
{
Edges.Add(new Edge(Id, Start, End, SizeModule, NumberModules, CostModule));
}
Sprite CacheTile(MPos uv, int offset, Edges edges, TileInfo tileInfo,
Sprite[] sprites, Vertex[] vertices, PaletteReference palette, CellLayer<Sprite> spriteLayer)
{
var sprite = GetSprite(sprites, edges, tileInfo.Variant);
if (sprite != null)
{
var size = sprite.Size;
var location = tileInfo.ScreenPosition - 0.5f * size;
OpenRA.Graphics.Util.FastCreateQuad(
vertices, location + sprite.FractionalOffset * size,
sprite, palette.TextureIndex, offset, size);
}
spriteLayer[uv] = sprite;
return sprite;
}
public void ReadEdges(byte[] memory)
{
UnknownList edges = new UnknownList();
Edges e = new Edges();
edges.size = BitConverter.ToInt32(memory, readerpos);
edges.count = BitConverter.ToInt32(memory, readerpos + 4);
e.size = edges.size;
e.count = edges.count;
readerpos += 8;
int len = edges.size * edges.count;
edges.data = new byte[len];
int datacounter = 0;
e.UVSet = new List<UVSet>();
for (int i = 0; i < edges.count; i++)
{
UVSet uv = new UVSet();
uv.UVs = new List<Vector2>();
uv.x1 = memory[readerpos];
uv.y1 = memory[readerpos + 1];
uv.z1 = memory[readerpos + 2];
uv.w1 = memory[readerpos + 3];
uv.x2 = memory[readerpos + 4];
uv.y2 = memory[readerpos + 5];
uv.z2 = memory[readerpos + 6];
uv.w2 = memory[readerpos + 7];
readerpos += 8;
for (int row = 0; row < (edges.size - 8) / 4; row++)
{
float u = DXHelper.HalfToFloat(BitConverter.ToUInt16(memory, readerpos));
float v = DXHelper.HalfToFloat(BitConverter.ToUInt16(memory, readerpos + 2));
uv.UVs.Add(new Vector2(u, v));
edges.data[datacounter] = memory[readerpos];
readerpos += 4;
datacounter += 1;
}
e.UVSet.Add(uv);
}
Mesh.Edges = e;
}
static int Main(string[] args)
{
ErrorNodeList enl = new ErrorNodeList();
ErrorHandler eh = new ErrorHandler(enl);
TypeSystem ts = new TypeSystem(eh);
//args = new string[]
// {
// //@"C:\Users\Jonathan Tapicer\Documents\Visual Studio 2010\Projects\escape_test\escape_test\bin\Debug\escape_test.dll",
// //@"C:\Users\Jonathan Tapicer\Desktop\tesis\cci_rewriter\example_with_contracts\Example\obj\Debug\Decl\Example.dll",
// @"C:\Users\Jonathan Tapicer\Desktop\tesis\cci_rewriter\experiments\experiments\obj\Debug\Decl\experiments.dll",
// };
if (args.Length == 0)
{
Console.WriteLine("Provide assembly full path as an argument.");
return 1;
}
AssemblyNode assembly = AssemblyNode.GetAssembly(
args[0],
true, true, true);
PointsToAnalysis pta = new PointsToAnalysis(ts, assembly, true, true, 3);
pta.Visit(assembly);
XmlTextWriter xml = new XmlTextWriter(Console.Out);
xml.Formatting = Formatting.Indented;
xml.WriteStartElement("ptg");
foreach (var method in pta.AnalyzedMethods())
{
xml.WriteStartElement("method");
xml.WriteAttributeString("type", method.DeclaringType.ToString());
xml.WriteAttributeString("name", method.Name.ToString());
var summ = pta.GetSummaryForMethod(method);
var ptg = summ.PointsToGraph;
//if (method.Name.ToString() == "M1") ptg.GenerateDotGraph("c:\\tmp\\ptg.dot");
//nodes escape
xml.WriteStartElement("escape");
var added = new List<string>();
foreach (var n in ptg.ReachableFromParametersReturnAndGlobals())
{
if (!added.Contains(n.Name))
{
xml.WriteStartElement("node");
xml.WriteAttributeString("name", n.Name);
if (n.Label != null && n.Label.Method != null)
{
xml.WriteAttributeString("method", n.Label.Method.DeclaringType.ToString() + "::" + n.Label.Method.Name);
}
xml.WriteEndElement(); //</node>
added.Add(n.Name);
}
}
xml.WriteEndElement(); //</escape>
//locals, params, ret, globals, fields inside nodes
xml.WriteStartElement("expressions");
Edges edges = new Edges();
edges.AddEdges(ptg.I);
edges.AddEdges(ptg.O);
foreach (var v in ptg.LV)
{
xml.WriteStartElement("expr");
if (ptg.RetValue == v.Key.Variable)
{
xml.WriteAttributeString("isReturn", "true");
}
xml.WriteAttributeString("val", v.Key.Name.Name);
Nodes nodesReacheable = Nodes.Empty;
var reacheableNodesExpressions = new Dictionary<string, Set<string>>(); //key are exprs, values are reacheable nodes by the expr
foreach (var addr in v.Value)
{
var nodesReacheableFromAddr = ptg.NodesForwardReachableFrom(addr);
nodesReacheable.AddRange(nodesReacheableFromAddr);
foreach (var nodeReacheableFromAddr in nodesReacheableFromAddr)
{
Set<IEnumerable<Edge>> pathsFromAddrToReacheableNode = (Set<IEnumerable<Edge>>)ptg.DFSPathFromTo(addr, nodeReacheableFromAddr, edges);
foreach (var path in pathsFromAddrToReacheableNode)
{
var pathFields = new List<string>();
foreach (var edge in path)
{
if (edge.Field.Name.Name != "*" &&
edge.Field.Name.Name != "?" &&
edge.Field.Name.Name != "$")
{
pathFields.Add(edge.Field.Name.Name);
}
}
if (!reacheableNodesExpressions.ContainsKey(nodeReacheableFromAddr.Name))
{
reacheableNodesExpressions.Add(nodeReacheableFromAddr.Name, new Set<string>());
}
var expr = "." + string.Join(".", pathFields);
if (!reacheableNodesExpressions[nodeReacheableFromAddr.Name].Contains(expr))
{
reacheableNodesExpressions[nodeReacheableFromAddr.Name].Add(expr);
}
}
}
}
xml.WriteStartElement("reaches");
foreach (var r in nodesReacheable)
{
if (r.Name != v.Key.Name.Name)
{
xml.WriteStartElement("node");
xml.WriteAttributeString("name", r.Name);
if (r.Label != null && r.Label.Method != null)
{
xml.WriteAttributeString("method", r.Label.Method.DeclaringType.ToString() + "::" + r.Label.Method.Name);
}
if (reacheableNodesExpressions.ContainsKey(r.Name))
{
foreach (var expr in reacheableNodesExpressions[r.Name])
{
xml.WriteStartElement("expr");
xml.WriteAttributeString("val", expr);
xml.WriteEndElement(); //</expr>
}
}
xml.WriteEndElement(); //</node>
}
}
xml.WriteEndElement(); //</reaches>
xml.WriteEndElement(); //</expr>
}
xml.WriteEndElement(); //</expressions>
xml.WriteEndElement(); //</method>
}
xml.WriteEndElement(); //</ptg>
return 0;
}
private void DeleteVertex(Vertex vertex)
{
Vertices = Vertices.Where(v => !ReferenceEquals(v, vertex)).ToArray();
Edges = Edges.Where(e => e.A != vertex && e.B != vertex).ToArray();
}
/// <summary>
/// Bind the caller with the callee and simplify the resulting pointsToGraph
/// by removing the load nodes that has been resolved (captured objects)
/// </summary>
/// <param name="callerPTG"></param>
/// <param name="calleePTG"></param>
/// <param name="vr"></param>
/// <returns></returns>
private void bindCallerWithCalleePTG(PTGraph callerPTG, PTGraph calleePTG, Variable vr)
{
// Compute Edges
Edges Inew = new Edges();
foreach (Edge ie in calleePTG.I)
{
foreach (IPTAnalysisNode nu1 in RelatedExtended(ie.Src))
{
foreach (IPTAnalysisNode nu2 in RelatedExtended(ie.Dst))
{
Inew.AddIEdge(nu1, ie.Field, nu2);
}
}
}
// Compute Edges
Edges Onew = new Edges();
foreach (Edge oe in calleePTG.O)
{
foreach (IPTAnalysisNode nu1 in RelatedExtended(oe.Src))
{
if (!nu1.IsNull)
Onew.AddOEdge(nu1, oe.Field, oe.Dst);
}
}
// Compute Escape
Nodes eNew = new Nodes();
foreach (IPTAnalysisNode n in calleePTG.E)
{
eNew.AddRange(RelatedExtended(n));
}
callerPTG.I.AddEdges(Inew);
callerPTG.O.AddEdges(Onew);
callerPTG.E.AddRange(eNew);
/// Assign vr = related(retValue)
Nodes argNodes = Nodes.Empty;
if (callerThisRef != null)
{
// argNodes.Add(callerPTG.GetAddress(callerThisRef));
argNodes.AddRange(callerPTG.GetLocations(callerThisRef));
}
if (calleePTG.Method.Parameters != null)
{
for (int i = 0; i < calleePTG.Method.Parameters.Count; i++)
{
Parameter p = calleePTG.Method.Parameters[i];
PNode pn = calleePTG.ParameterMap[p];
if (!pn.IsByValue)
{
if (arguments[i] is Variable)
{
Variable vArg = (Variable)arguments[i];
bindRefOrOutParameter(callerPTG, calleePTG, arguments[i] as Variable, p);
}
}
if (arguments[i] is Variable)
{
Variable vArg = (Variable)arguments[i];
// PTAnalysisNode addrArg = callerPTG.GetAddress(vArg);
// argNodes.Add(addrArg);
argNodes.AddRange(callerPTG.GetLocations(vArg));
}
}
}
if (vr != null)
{
if (!vr.Type.IsPrimitive && calleePTG.RetValue != null)
{
callerPTG.AddVariable(vr, callerPTG.MethodLabel);
Nodes relatedValues2 = Nodes.Empty;
// PTAnalysisNode addrRetValue = calleePTG.GetAddress(calleePTG.RetValue);
// foreach (PTAnalysisNode n2 in calleePTG.Values(addrRetValue))
foreach (IPTAnalysisNode n2 in calleePTG.Values(calleePTG.GetLocations(calleePTG.RetValue)))
{
relatedValues2.AddRange(RelatedExtended(n2));
}
callerPTG.Assign(vr, relatedValues2, calleePTG.MethodLabel);
}
else
{
callerPTG.ForgetVariable(vr);
}
}
// Now we can remove the load nodes that don't escape
Set<LNode> lNodes = callerPTG.LoadNodes;
// B = Nodes forward reachable from from Escaping, Parameters, callee Arguments and Global nodes
Nodes B = callerPTG.ReachableFromParametersReturnAndGlobalsAnd(argNodes);
foreach (LNode ln in lNodes)
{
Set<Edge> IToRemove = new Set<Edge>();
Set<Edge> OToRemove = new Set<Edge>();
// If the LoadNode is not reachable or it is captured
if (!B.Contains(ln) || (Related(ln).Count > 0))
// if (!B.Contains(ln) || (ln.IsParameterValueLNode && (Related(ln).Count > 0 || !Related(ln).Contains(ln))))
//if (!B.Contains(ln) /*&& (ln is LAddrFieldNode */
// /*&& ln.Label.Method.Equals(callerPTG.Method)*/)
{
foreach (Edge ie in callerPTG.I.EdgesFromSrc(ln))
IToRemove.Add(ie);
foreach (Edge ie in callerPTG.I.EdgesFromDst(ln))
IToRemove.Add(ie);
foreach (Edge oe in callerPTG.O.EdgesFromDst(ln))
OToRemove.Add(oe);
foreach (Edge oe in callerPTG.O.EdgesFromSrc(ln))
OToRemove.Add(oe);
removedLoadNodes.Add(ln);
}
callerPTG.I.RemoveEdges(IToRemove);
callerPTG.O.RemoveEdges(OToRemove);
}
}
private void DeleteEdge(Edge edge)
{
Edges = Edges.Where(x => !ReferenceEquals(x, edge)).ToArray();
}
public ShroudRenderer(World world, ShroudRendererInfo info)
{
if (info.ShroudVariants.Length != info.FogVariants.Length)
throw new ArgumentException("ShroudRenderer must define the same number of shroud and fog variants!", "info");
if ((info.OverrideFullFog == null) ^ (info.OverrideFullShroud == null))
throw new ArgumentException("ShroudRenderer cannot define overrides for only one of shroud or fog!", "info");
if (info.ShroudVariants.Length > byte.MaxValue)
throw new ArgumentException("ShroudRenderer cannot define this many shroud and fog variants.", "info");
if (info.Index.Length >= byte.MaxValue)
throw new ArgumentException("ShroudRenderer cannot define this many indexes for shroud directions.", "info");
this.info = info;
map = world.Map;
tileInfos = new CellLayer<TileInfo>(map);
// Load sprite variants
var variantCount = info.ShroudVariants.Length;
variantStride = (byte)(info.Index.Length + (info.OverrideFullShroud != null ? 1 : 0));
shroudSprites = new Sprite[variantCount * variantStride];
fogSprites = new Sprite[variantCount * variantStride];
var sequenceProvider = map.Rules.Sequences;
for (var j = 0; j < variantCount; j++)
{
var shroud = sequenceProvider.GetSequence(info.Sequence, info.ShroudVariants[j]);
var fog = sequenceProvider.GetSequence(info.Sequence, info.FogVariants[j]);
for (var i = 0; i < info.Index.Length; i++)
{
shroudSprites[j * variantStride + i] = shroud.GetSprite(i);
fogSprites[j * variantStride + i] = fog.GetSprite(i);
}
if (info.OverrideFullShroud != null)
{
var i = (j + 1) * variantStride - 1;
shroudSprites[i] = sequenceProvider.GetSequence(info.Sequence, info.OverrideFullShroud).GetSprite(0);
fogSprites[i] = sequenceProvider.GetSequence(info.Sequence, info.OverrideFullFog).GetSprite(0);
}
}
// Mapping of shrouded directions -> sprite index
edgesToSpriteIndexOffset = new byte[(byte)(info.UseExtendedIndex ? Edges.All : Edges.AllCorners) + 1];
for (var i = 0; i < info.Index.Length; i++)
edgesToSpriteIndexOffset[info.Index[i]] = (byte)i;
if (info.OverrideFullShroud != null)
edgesToSpriteIndexOffset[info.OverrideShroudIndex] = (byte)(variantStride - 1);
notVisibleEdges = info.UseExtendedIndex ? Edges.AllSides : Edges.AllCorners;
}
/// <summary>
/// Clears the graph ready for new node insertions.
/// </summary>
public void Clear()
{
NextNodeIndex = 0;
Nodes.Clear();
Edges.Clear();
}
public Edges ObscuredFrom(int x, int y, int z)
{
Edges obsc = 0;
var self = SpanAt(x, y);
if (self != null) {
if (self.Voxels.Any(v => v.Z == z + 1)) {
obsc |= Edges.ZMore;
}
if (self.Voxels.Any(v => v.Z == z - 1)) {
obsc |= Edges.ZLess;
}
var off = new Vector2[] {
new Vector2(-1, 0),
new Vector2(+1, 0),
new Vector2(0, -1),
new Vector2(0, +1),
};
var edgeoff = new Edges[] { Edges.XLess, Edges.XMore, Edges.YLess, Edges.YMore };
for (var i = 0; i < 4; ++i) {
var shift = off[i];
var edge = edgeoff[i];
var neighbour = SpanAt(x + (int)shift.X, y + (int)shift.Y);
if (neighbour != null) {
if (neighbour.Voxels.Any(v => v.Z == z)) {
obsc |= edge;
}
}
}
}
return obsc;
}
public List <Tin_Point> GetValueLine(List <Triangle> triangles, double value, List <Tin_Point> theline, int type)//递归调用
{
Edges firstedges = null;
Triangle theTriangle = null;
int sign = -1;
if (triangles.Count <= 0)
{
return(null);
}
for (int i = 0; i < triangles.Count; i++)
{
if (GetValidEdges(triangles[i], value) != null && !triangles[i].flag)
{
firstedges = GetValidEdges(triangles[i], value);
firstedges = Index(firstedges);
//Console.WriteLine(firstedges.ToString());
theTriangle = triangles[i];
sign = i;
//Console.WriteLine("三角形序号为：" + sign + "被使用");
//Console.WriteLine(theTriangle.ToString());
break;
}
else
{
triangles[i].flag = true;
//Console.WriteLine("三角形序号为：" + i + "已被使用或没有该等值点");
//Console.WriteLine("三角形" + i + ": " + triangles[i].ToString());
}
}
if (firstedges == null || theTriangle == null)
{
return(theline);
}
var theedge = firstedges;
var thePoint = GetValuePoint(firstedges, value, type);
thePoint.Num = NumOfEdges(theedge);
//Console.WriteLine("点的层数（type）为:" + thePoint.ToString() +";现在的层数（type）为："+type);
theline.Add(thePoint);
while (true)
{
/*for(int i = 0; i < triangles.Count; i++)
* {
* if (triangles[i].flag == false)
* break;
* else if (i - 1 == triangles.Count && triangles[i].flag == true)
* {
*
* }
* }//检测三角形数组中还有没有没有搜索到的三角形*/
triangles[sign].flag = true;
var edgess = EdgesForTriangle(theedge, theTriangle);
int useEdge;
if (ContainPoint(edgess[0], value))
{
useEdge = 0;
}
else
{
useEdge = 1;
}
thePoint = GetValuePoint(edgess[useEdge], value, type);
/*if (thePoint == null)
* {
* thePoint = GetValuePoint(edgess[1], value, type);
* useEdge = 1;
*
* }
* Console.WriteLine(edgess[0].ToString());
* Console.WriteLine(edgess[1].ToString());
* Console.ReadKey();*/
thePoint.Num = NumOfEdges(edgess[useEdge]);
theline.Add(thePoint);
theedge = edgess[useEdge];
theedge = Index(theedge);//变成了序号为4的边？应该是序号为8的边
sign = GetOtherTriangle(theedge, sign);
//Console.WriteLine(sign + ": " + theedge.SignT1 + "," + theedge.SignT2);
//Console.WriteLine("re三角形序号为：" + sign + "被使用");
//theTriangle = GetOtherTriangle(theedge, theTriangle);
if (sign == -1)
{
if (CheckTriangle(triangles))
{
type++;
Console.WriteLine("进入重载函数进行递归循环" + type);
return(GetValueLine(triangles, value, theline, type));
//未完待续
}
else
{
//break;
return(theline);
}
}
else
{
theTriangle = triangles[sign];
}
if (theTriangle.flag)
{
if (CheckTriangle(triangles))
{
type++;
Console.WriteLine("进入重载函数进行递归循环" + type);
return(GetValueLine(triangles, value, theline, type));
//未完待续
}
else
{
//break;
return(theline);
}
}
}
}
/// <include file='doc\VisualStyleRenderer.uex' path='docs/doc[@for="VisualStyleRenderer.DrawEdge"]/*' />
/// <devdoc>
/// <para>
/// [See win32 equivalent.]
/// </para>
/// </devdoc>
public Rectangle DrawEdge(IDeviceContext dc, Rectangle bounds, Edges edges, EdgeStyle style, EdgeEffects effects) {
if (dc == null) {
throw new ArgumentNullException("dc");
}
if (!ClientUtils.IsEnumValid_Masked(edges, (int)edges,(UInt32)(Edges.Left | Edges.Top | Edges.Right | Edges.Bottom | Edges.Diagonal))) {
throw new InvalidEnumArgumentException("edges", (int)edges, typeof(Edges));
}
if (!ClientUtils.IsEnumValid_NotSequential(style, (int)style, (int)EdgeStyle.Raised,(int)EdgeStyle.Sunken,(int)EdgeStyle.Etched,(int)EdgeStyle.Bump )) {
throw new InvalidEnumArgumentException("style", (int)style, typeof(EdgeStyle));
}
if (!ClientUtils.IsEnumValid_Masked(effects, (int)effects, (UInt32)(EdgeEffects.FillInterior | EdgeEffects.Flat | EdgeEffects.Soft | EdgeEffects.Mono))) {
throw new InvalidEnumArgumentException("effects", (int)effects, typeof(EdgeEffects));
}
NativeMethods.COMRECT rect = new NativeMethods.COMRECT();
using( WindowsGraphicsWrapper wgr = new WindowsGraphicsWrapper( dc, AllGraphicsProperties ) ) {
HandleRef hdc = new HandleRef( wgr, wgr.WindowsGraphics.DeviceContext.Hdc );
lastHResult = SafeNativeMethods.DrawThemeEdge( new HandleRef( this, Handle ), hdc, part, state, new NativeMethods.COMRECT( bounds ), (int) style, (int) edges | (int) effects | EdgeAdjust, rect );
}
return Rectangle.FromLTRB(rect.left, rect.top, rect.right, rect.bottom);
}
public void ComputeMyDimensions(ref Edges edg)
{
edg.areaNode1 = TriangleArea(edg.node1, edg.side1, edg.side2);
edg.areaNode2 = TriangleArea(edg.node2, edg.side2, edg.side1);
edg.boundaryLength = EdgeLength(edg.side1, edg.side2);
}
public void Add(Edge edge)
{
Edges.Add(edge);
}
void FindAllPairs()
{
int i1, i2, i3;
int totalUnique = nT; // dec for each dup found
Edges[] allPairs = new Edges[nT];
for (int tn = 0; tn < nT; tn += 3)
{
i1 = trianglesArray [tn];
i2 = trianglesArray [tn + 1];
i3 = trianglesArray [tn + 2];
allPairs [tn] = new Edges(i1, i2, i3);
allPairs[tn + 1] = new Edges(i2, i3, i1);
allPairs[tn + 2] = new Edges(i3, i1, i2);
}
for (int n = 0; n < nT - 1; n++)
{
if (allPairs [n].dup)
{
continue;
}
for (int m = n + 1; m < nT; m++)
{
if (allPairs [m].dup)
{
continue;
}
if ((allPairs[n].node1 == allPairs[m].node1) & (allPairs[n].node2 == allPairs[m].node2))
{
allPairs [n].dup = true;
allPairs [m].dup = true;
allPairs [n].side2 = allPairs [m].side1;
allPairs [m].side2 = allPairs [n].side1; // Not really needed, as will be excluded.
allPairs [m].dopple = true; // tag which one to exclude
totalUnique -= 1;
break;
}
}
}
nE = totalUnique;
edges = new Edges[nE];
int walk = 0;
float totBound = 0;
float totArea = 0;
for (int j = 0; j < nT; j++)
{
if (!allPairs [j].dopple)
{
edges [walk] = allPairs [j];
ComputeMyDimensions(ref edges[walk]);
totBound += edges [walk].boundaryLength;
totArea += edges [walk].areaNode1;
vertAreas [edges [walk].node1] += edges [walk].areaNode1;
walk += 1;
}
}
Debug.Log("n triangles " + nT);
Debug.Log("n edges " + nE);
Debug.Log("n vert " + nV);
Debug.Log("avg boundary length " + totBound / (1.0f * nT));
Debug.Log("avg area " + totArea / (1.0f * nT));
}
public void Remove(Edge edge)
{
Edges.Remove(edge);
}
public void AddEdge(Relationship edge)
{
Edges.Add(edge);
}
