public HeatMapUpdater(int _index,Node[] _nodes,Grid _grid){
		index = _index;
		nodes = _nodes;
		grid = _grid;
		a = new Thread(UpdateHeatMap);
		a.Start();
	}

 public void Init(Legs legs,Grid grid)
 {
     base.Init(legs);
     this.grid = grid;
     this.auxiliarySteering = new Arrive();
     this.auxiliarySteering.Init(getLegs());
 }

    public Vector3 wloc; // 3D location coordinates in Unity's world units

    #endregion Fields

    #region Constructors

    public Square(Grid gr, Vector2 loc, Vector3 wloc)
    {
        this.plane = GameObject.CreatePrimitive(PrimitiveType.Plane);
        plane.name = "Grid plane";
        plane.transform.position = wloc;
        plane.transform.localScale = new Vector3(0.1f, 1.0f, 0.1f);
        plane.transform.Rotate(-90.0f, 0.0f, 0.0f);
        plane.renderer.material.mainTexture = Resources.Load("Textures/Tile2") as Texture;
        plane.renderer.material.color = Color.white;
        colors = new Dictionary<Color, int>();
        colors[Color.red] = 0;
        colors[Color.green] = 0;
        colors[Color.blue] = 0;
        colors[Color.yellow] = 0;
        this.loc = loc;
        this.wloc = wloc;
        objects = new List<GameObject>();
        board = new Square[8];
        int count = 0;
        for(int xof = -1; xof <= 1; xof++) {
            for(int yof = -1; yof <= 1; yof++) {
                int x = (int)loc.x;
                int y = (int)loc.y;
                if(!(xof == 0 && yof == 0)) {
                    if(x+xof >= 0 && x+xof < gr.width && y+yof >= 0 && y+yof < gr.height)
                        board[count] = gr.grid[x+xof, y+yof];
                    count++;
                }
            }
        }
    }

        /// <summary>Creates the UI elements for the given HTML node and HTML view.</summary>
        /// <param name="node">The HTML node.</param>
        /// <param name="htmlView">The HTML view.</param>
        /// <returns>The UI elements.</returns>
        public DependencyObject[] CreateControls(HtmlNode node, IHtmlView htmlView)
        {
            var controls = new List<Grid>();
            foreach (var child in node.Children.OfType<HtmlTagNode>().Where(c => c.Name == "li"))
            {
                var grid = new Grid();
                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(20)});
                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });

                var textBlock = CreateBulletSymbol(htmlView);
                                grid.Children.Add(textBlock);
                Grid.SetColumn(textBlock, 0);

                var panel = new StackPanel();

                child.WrapWithHtmlTag();
                foreach (var c in child.GetChildControls(htmlView).OfType<UIElement>())
                {
                    var frameworkElement = c as FrameworkElement;
                    if (frameworkElement != null)
                        frameworkElement.HorizontalAlignment = HorizontalAlignment.Stretch;

                    panel.Children.Add(c);
                }

                grid.Children.Add(panel);
                Grid.SetColumn(panel, 1);

                controls.Add(grid);
            }

            AdjustMargins(htmlView, controls);
            return controls.OfType<DependencyObject>().ToArray();
        }

    //FOR N_Back!
    public void GenerateGrounds(Grid grid, TerrainChunk tc, int y = 0, 
	                             bool ceiling = false)
    {
        // Generate ground and potholes
        //First and last cannot be a hole.
        for (int i = 0; i < grid.numCellsX; ++i) {
            if (grid.containsObject(i, y)) {
                continue;
            }

            //level is chance that there is a hole! Do not spawnground!
            //int rand = Random.Range (0, 101);

            //if(!(i ==0 || i == grid.numCellsX))
            //{
            if (initCeiling == 0) {
                initCeiling++;
                continue;
            }
            //}

            // Generate random width ground pieces varying from 1-3
            int cap, roll;
            do {
                //cap = Mathf.Min (4, grid.numCellsX - i + 1);
                roll = 3;
            } while (!GenerateWideGround(i, y, roll, grid, tc, ceiling));
        }
    }

        public void GetVisualParents() {
#endif
            Grid grid = new Grid();
            ContentControl contentControl = new ContentControl();
            TextBox textBox;
            Window.Content = grid;
            grid.Children.Add(contentControl);
            contentControl.ContentTemplate = textBoxTemplate;
#if NETFX_CORE
            await
#endif
            EnqueueShowWindow();
            EnqueueCallback(() => {
                textBox = (TextBox)LayoutHelper.FindElement(contentControl, x => x is TextBox);
                Assert.AreSame(contentControl, LayoutTreeHelper.GetVisualParents(textBox).Where(x => x is ContentControl).First());
                Assert.AreSame(grid, LayoutTreeHelper.GetVisualParents(textBox).Where(x => x is Grid).First());
                Assert.AreSame(Window, LayoutTreeHelper.GetVisualParents(textBox).Where(x => x.GetType() == Window.GetType()).First());

                Assert.AreSame(contentControl, LayoutTreeHelper.GetVisualParents(textBox, contentControl).Where(x => x is ContentControl).First());
                Assert.IsNull(LayoutTreeHelper.GetVisualParents(textBox, contentControl).Where(x => x is Grid).FirstOrDefault());

                var presenter = LayoutTreeHelper.GetVisualChildren(contentControl).First();
                Assert.IsTrue(new[] { presenter }.SequenceEqual(LayoutTreeHelper.GetVisualParents(textBox, presenter)));
            });
            EnqueueTestComplete();
        }

        public void Calling_AutoGenerateColumns_should_add_columns()
        {
            IGrid<Person> grid = new Grid<Person>(new Person[0], new ViewContext());
            grid.AutoGenerateColumns();

            ((Grid<Person>)grid).Model.Columns.Count.ShouldEqual(2);
        }

        public void Grid_SetsName()
        {
            String actual = new Grid<GridModel>(new GridModel[0]).Name;
            String expected = "Grid";

            Assert.Equal(expected, actual);
        }

            public override TerrainGrid Generate(Vector size, FreqDict freqs = null, Random rand = null)
            {
                freqs = freqs ?? _defaultFreqs;
                UpdateFreqs(ref freqs);
                NormalizeFreqs(ref freqs);

                rand = rand ?? new Random();

                var terrain = new Grid<TerrainType>(size);

                var heightGrid = _topographyGenerator.Generate(terrain.Size, rand);
                heightGrid = _filters.OpenClose(heightGrid);
                var sortedPoints = heightGrid.GetPoints().ToList();
                sortedPoints.Sort((lhs, rhs) => (heightGrid[lhs] - heightGrid[rhs]));

                int numTiles = size.x * size.y;
                int numWaterTiles = (int)(numTiles * freqs[TerrainTypes.Water]);
                var waterTiles = sortedPoints.Take(numWaterTiles);
                foreach (var point in waterTiles)
                    terrain[point] = TerrainTypes.Water;

                int numMountainTiles = (int)(numTiles * freqs[TerrainTypes.Mountain]);
                var mountainTiles = sortedPoints.Skip(numTiles - numMountainTiles);
                foreach (var point in mountainTiles)
                    terrain[point] = TerrainTypes.Mountain;

                var landTiles = new HashSet<Vector>(terrain.GetPoints());
                landTiles.ExceptWith(waterTiles);
                landTiles.ExceptWith(mountainTiles);

                AddLandTiles(ref terrain, landTiles.ToList(), freqs, rand);

                return terrain;
            }

 void Start()
 {
     _root = (Grid)GetComponent<NoesisGUIPanel>().GetContent();
     _root.ManipulationStarting += this.ManipulationStarting;
     _root.ManipulationInertiaStarting += this.ManipulationInertiaStarting;
     _root.ManipulationDelta += this.ManipulationDelta;
 }

        public void Grid_SetsSource()
        {
            IQueryable<GridModel> expected = new GridModel[2].AsQueryable();
            IQueryable<GridModel> actual = new Grid<GridModel>(expected).Source;

            Assert.Same(expected, actual);
        }

		protected override void Init ()
		{
			var rootGrid = new Grid {
				RowDefinitions = new RowDefinitionCollection
														  {
															 new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
															 new RowDefinition { Height = new GridLength(1, GridUnitType.Auto) },
														 },
			};


			_mainContent = new ContentView { Content = new ScrollView { Content = new Label { Text = Description } } };
			rootGrid.AddChild (_mainContent, 0, 0);


			var buttons = new StackLayout { Orientation = StackOrientation.Horizontal };

			var button1A = new Button { Text = "View 1A" };
			button1A.Clicked += (sender, args) => ShowView (_view1A);
			buttons.Children.Add (button1A);

			var button1B = new Button { Text = "View 1B" };
			button1B.Clicked += (sender, args) => ShowView (_view1B);
			buttons.Children.Add (button1B);

			var button2 = new Button { Text = "View 2" };
			button2.Clicked += (sender, args) => ShowView (_view2);
			buttons.Children.Add (button2);

			rootGrid.AddChild (buttons, 0, 1);


			Content = rootGrid;
		}

    protected void AddDetailGrid(Grid grid)
    {
        DetailGrid detail = new DetailGrid();
        detail.ID = "grid" + level.ToString();
        detail.AutoGenerateColumns = false;
        detail.Serialize = false;
        detail.AllowPageSizeSelection = false;
        detail.AllowPaging = false;
        detail.PageSize = -1;
        detail.AllowAddingRecords = true;
        detail.Width = Unit.Percentage(97);

        detail.ForeignKeys = "CategoryID";

        detail.ClientSideEvents.ExposeSender = true;
        detail.ClientSideEvents.OnClientPopulateControls = "onPopulateControls";
        detail.ClientSideEvents.OnBeforeClientDelete = "onBeforeClientDelete";

        foreach (Column column in grid.Columns)
        {
            Column newColumn = column.Clone() as Column;
            newColumn.SortOrder = SortOrderType.None;
            detail.Columns.Add(newColumn);
        }

        detail.MasterDetailSettings = grid.MasterDetailSettings;

        detail.DataSourceNeeded += Grid1_DataSourceNeeded;
        detail.InsertCommand += Grid1_InsertCommand;
        detail.UpdateCommand += Grid1_UpdateCommand;
        detail.DeleteCommand += Grid1_DeleteCommand;

        grid.DetailGrids.Add(detail);
    }

        public void Grid_Encode()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);
            m.Load(@".\data\test.xml");
            m.ZoomAll();
            Grid g = new Grid(256, 256);
            var options = new Dictionary<string, object>()
            {
                {"Fields", new List<string>() { "FIPS" } },
                {"Layer", "world" }
            };

            m.Render(g, options);
            Dictionary<string, object> UTFGridDict = g.Encode();

            Assert.AreEqual(UTFGridDict.Keys.Count, 3);

            //Test for keys
            List<string> keyList = (List<string>)UTFGridDict["keys"];
            Assert.AreNotEqual(keyList.Count, 0);

            //Test for data
            Dictionary<string, object> dataDict = (Dictionary<string, object>)UTFGridDict["data"];
            Assert.AreNotEqual(dataDict.Count, 0);

            //data count should equal keys + 1
            Assert.AreEqual(keyList.Count, dataDict.Count + 1);
        }

        public void GridCellInstantiationTest()
        {
            Grid grid;

            // Assert each cell in grid is instantiated and initialized with expected default chemical concentrations
            grid = new Grid(4);
            for (int column = 0; column < grid.Size; column++)
            {
                for (int row = 0; row < grid.Size; row++)
                {
                    Assert.AreEqual(grid[column, row]["A"], 0);
                    Assert.AreEqual(grid[column, row]["B"], 0);
                }
            }

            // Assert each cell in grid is instantiated and initialized with given chemical concentrations
            Cell cell = new Cell
            {
                { "A", 0.25 },
                { "B", 0.75 }
            };
            grid = new Grid(4, cell);
            for (int column = 0; column < grid.Size; column++)
            {
                for (int row = 0; row < grid.Size; row++)
                {
                    Assert.AreEqual(grid[column, row]["A"], 0.25);
                    Assert.AreEqual(grid[column, row]["B"], 0.75);
                }
            }
        }

 public void Grid_Key()
 {
     Grid g = new Grid(256, 256);
     Assert.AreEqual("__id__", g.Key);
     g.Key = "key";
     Assert.AreEqual("key", g.Key);
 }

 public override void Click(float mouseX, float mouseY, int gridX, int gridY, Grid grid, GridPiece piece)
 {
     if (piece == null)
     {
         grid.AddPiece(new Battery(new ChargeColor(R, G, B)), gridX, gridY);
     }
 }

        protected override void Init()
        {
            var label = new Label { Text = "Label" };
            var entry = new Entry { AutomationId = "entry" };
            var grid = new Grid();

            grid.Children.Add(label, 0, 0);
            grid.Children.Add(entry, 1, 0);
            var tableView = new TableView
            {
                Root = new TableRoot
                {
                    new TableSection
                    {
                        new ViewCell
                        {
                            View = grid
                        }
                    }
                }
            };

            Content = new StackLayout
            {
                Children = { tableView }
            };
        }

    public static void AddPages(TabControl tabControl, string tabName, bool maxSize, params Page[] pages)
    {
        Grid grid = new Grid();
        grid.Width = double.NaN;
        grid.Height = double.NaN;
        grid.Margin = new Thickness(0);
        grid.VerticalAlignment = VerticalAlignment.Top;

        if (maxSize)
        {
            grid.HorizontalAlignment = HorizontalAlignment.Stretch;
            grid.VerticalAlignment = VerticalAlignment.Stretch;
        }

        int index = 0;
        foreach (var item in pages)
        {
            ColumnDefinition col = new ColumnDefinition();
            col.Width = GridLength.Auto;
            grid.ColumnDefinitions.Add(col);
            SetPageToGrid(item, grid, 0, index);
            index++;
        }

        TabItem tabItem = new TabItem();
        tabItem.Header = tabName;
        tabItem.Content = grid;
        tabControl.Items.Add(tabItem);
    }

            public override HashSet<Vector> Find(TerrainGrid terrain)
            {
                var interestPoints = new HashSet<Vector>();

                var blocking = new Grid<bool>(terrain.Size);
                foreach (var point in terrain.GetPoints())
                {
                    var terrainType = terrain[point];
                    blocking[point] = TerrainTypes.Blocking.Contains(terrainType);
                }

                blocking = _filters.Close(blocking);

                var areas = _areaFinder.Find(blocking).ToList();
                areas.RemoveAll((area) => area.Count <= 20);
                foreach (var area in areas)
                {
                    var areaList = area.ToList();
                    int xMean = (int)areaList.Average((p) => p.x);
                    int yMean = (int)areaList.Average((p) => p.y);
                    Vector centroid = new Vector(xMean, yMean);
                    interestPoints.Add(centroid);
                }

                return interestPoints;
            }