Esempio n. 1
0
        public void CalculateHeat()
        {
            if (HeatMap == null || HeatMap.GetLength(0) != SoilMap.GetLength(0) || HeatMap.GetLength(1) != SoilMap.GetLength(1))
            {
                HeatMap = new float[SoilMap.GetLength(0), SoilMap.GetLength(1)];
            }

            switch (Type)
            {
            case HeatTypes.SoilDepth:
                CalculateSoilDepth();
                break;

            case HeatTypes.WaterDepth:
                CalculateWaterDepth();
                break;

            case HeatTypes.SoilHumidity:
                CalculateSoilHumidity();
                break;

            case HeatTypes.Inclination:
                CalculateInclination();
                break;
            }
        }
Esempio n. 2
0
        internal static VectorTile GetVectorTile(this HeatMap heatMap, ulong tileId, uint resolution)
        {
            var tile = new Tile(tileId);
            var tgt  = new TileGeometryTransform(tile, resolution);

            var vectorTile = new VectorTile()
            {
                TileId = tileId,
                Layers = { new Layer()
                           {
                               Name = "heatmap"
                           } }
            };

            foreach (var(x, y, value) in heatMap.GetValues(tileId, resolution))
            {
                if (value == 0)
                {
                    continue;
                }

                var coordinate = tgt.TransformTo(x, y);
                vectorTile.Layers[0].Features.Add(new Feature(
                                                      new Point(new Coordinate(coordinate.longitude, coordinate.latitude)),
                                                      new AttributesTable {
                    { "cost", value }
                }));
            }

            return(vectorTile);
        }
Esempio n. 3
0
        static void Main(string[] args)
        {
            var features = (new GeoJsonReader()).Read <FeatureCollection>(
                File.ReadAllText(@"/data/ANYWAYS Dropbox/data/bike-data-project/test-belgium.geojson"));

            Console.WriteLine("Adding features...");
            var heatmap = new HeatMap(14, 1024);

            foreach (var feature in features)
            {
                heatmap.Add(feature, 1);
            }

            // convert to a vector tile tree.d
            var tree = heatmap.ToVectorTiles(14, 14, i =>
            {
                if (i == 14)
                {
                    return(1024);
                }

                return(256);
            });

            // write the tiles to disk as mvt.
            Console.WriteLine("Writing tiles...");
            tree.Write("tiles");
        }
    public void EndGame()
    {
        //screenManager.Toggle_RetryMenu(true);
        GameActive = false;
        Collectibles.Clear();

        if (score > highscore)
        {
            highscore = score;
            //highScore.text = "New High\nScore:\n" + highscore.ToString();
            //currScoreRetry.enabled = false;
        }
        else
        {
            //highScore.text = "High\nScore:\n" + highscore.ToString();
            //currScoreRetry.enabled = true;
            //currScoreRetry.text = "current score: " + score.ToString();
        }

        //Connecting to AWS servers to feed data
        HeatMap sessionData = new HeatMap
        {
            ID       = System.Guid.NewGuid().ToString(),
            User     = PlayerPrefs.GetString("User"),
            Time     = System.DateTime.UtcNow.ToString(),
            GameType = "Abstract",
            Spawned  = SpawnedArray,
            Collect  = CollectArray,
        };

        AWSMan aws = new AWSMan();

        aws.CreateItem(sessionData);
    }
Esempio n. 5
0
    public void DrawMapInEditor()
    {
        textureData.ApplyToMaterial(terrainMaterial);
        textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight);
        HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, Vector2.zero);
        HeatMap   heatMap   = HeatMapGenerator.GenerateHeatMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMap, heatMapSettings, Vector2.zero);
        TreeMap   treeMap   = TreeMapGenerator.generateVegetationMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMap, heatMap, treeMapSettings, Vector2.zero);

        DestroyTrees();          //temporary fix

        if (drawMode == DrawMode.HeightMap)
        {
            DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap));
        }
        else if (drawMode == DrawMode.Mesh)
        {
            DrawMesh(MeshGenerator.GenerateTerrainMesh2(heightMap.values, meshSettings, editorPreviewLOD, heatMap.values));
            DrawTrees(heightMap.values, meshSettings, treeMap.values);
        }
        else if (drawMode == DrawMode.FalloffMap)
        {
            DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numVertsPerLine), 0, 1)));
        }
        else if (drawMode == DrawMode.HeatMap)
        {
            DrawTexture(TextureGenerator.TextureColorizedFromHeatMap(heatMap));
        }
        else if (drawMode == DrawMode.TreeMap)
        {
            DrawTexture(TextureGenerator.TextureFromTreeMap(treeMap));
        }
    }
Esempio n. 6
0
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector(); // HeatMap class values
        HeatMap myTarget = (HeatMap)target;

        EditorGUILayout.Separator(); // Button Controls
        if (GUILayout.Button(myTarget.GridCreated() ? "Reload" : "Build"))
        {
            myTarget.ReloadGrid();
        }
        if (GUILayout.Button("Clear"))
        {
            myTarget.ClearGrid();
        }

        EditorGUILayout.Separator(); // Type & Scale
        HeatMap.HeatmapSHOW current_type = myTarget.type;
        myTarget.SetType((HeatMap.HeatmapSHOW)EditorGUILayout.EnumPopup("Type", current_type));
        myTarget.UpdateYScale(EditorGUILayout.FloatField("Y Scale", myTarget.y_scale));

        EditorGUILayout.Separator(); // Normalize
        myTarget.ToggleNormalized(GUILayout.Toggle(current = myTarget.normalized, "Normalize"));

        EditorGUILayout.Separator(); // Hide Empty
        myTarget.ToggleHideEmpty(GUILayout.Toggle(current = myTarget.hide_empty, "Hide Empty"));

        EditorGUILayout.Separator(); // Data info
        GUILayout.Label("Total Entries: " + myTarget.entries_count);
        GUILayout.Label("Max Speed: " + myTarget.max_speed);
        GUILayout.Label("Max Entries per cell: " + myTarget.max_entries_per_grid);
        GUILayout.Label("Max Average Speed per cell: " + myTarget.max_average_speed);
    }
        public GameStateViewModel([NotNull] States.GameState state, Genes.ActorChromosome brain)
        {
            _state = state ?? throw new ArgumentNullException(nameof(state));

            foreach (var actor in _state.World.Actors.Where(a => a.IsActive))
            {
                Actors.Add(new ActorViewModel(actor));
            }

            var values = new Dictionary <WorldPos.WorldPos, double>();

            for (int y = 1; y <= state.World.MaxY; y++)
            {
                for (int x = 1; x <= state.World.MaxX; x++)
                {
                    var pos = new WorldPos.WorldPos(x, y);
                    values[pos] = Genes.evaluateTile(brain, state.World, pos);
                }
            }

            var min = values.Values.Min();
            var max = values.Values.Max();

            foreach (var(pos, value) in values)
            {
                HeatMap.Add(new HeatMapViewModel(pos, value, min, max));
            }
        }
Esempio n. 8
0
        void UpdateHeatMap()
        {
            float boost = _slider.Value;

            _imageView.Image = HeatMap.HeatMapForMapView(_mapView, boost, _locations, _weights);
            UIView.Animate(0.2, () => _imageView.Alpha = 1, () => _imageView.Hidden = false);
        }
Esempio n. 9
0
        private void POnMouseEnter(object sender, MouseEventArgs mouseEventArgs)
        {
            var path = (Path)sender;

            path.Opacity = .8;

            var land = Lands.Values.FirstOrDefault(x => x.Shape == sender);

            if (land == null)
            {
                return;
            }

            double value;

            if (!HeatMap.TryGetValue(land.Id, out value))
            {
                return;
            }

            GeoMapTooltip.Visibility = Visibility.Visible;
            GeoMapTooltip.GeoData    = new GeoData
            {
                Name  = land.Name,
                Value = value
            };
        }
Esempio n. 10
0
        public async Task <IActionResult> Post(int?id, [FromBody] HeatMapDto heatMap)
        {
            if (id == null || id <= 0)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                Project projectToUpdate = await context.Projects
                                          .SingleOrDefaultAsync(p => p.ProjectId == id);

                if (projectToUpdate == null)
                {
                    return(NotFound());
                }
                HeatMap heatMapToInsert = mapper.Map <HeatMap>(heatMap);

                context.HeatMaps.Add(heatMapToInsert);
                projectToUpdate.DateUpdated = DateTime.Now;

                await context.SaveChangesAsync();

                return(Ok(mapper.Map <HeatMapDto>(heatMapToInsert)));
            }

            return(BadRequest(ModelState));
        }
Esempio n. 11
0
        private void Button1_Click(object sender, EventArgs e)
        {
            var width  = pictureBox1.Width;
            var height = pictureBox1.Height;
            var hp     = new HeatMap(width, height);

            pictureBox1.Image = hp.MapGenerate(pictureBox1, HeatPoints);
        }
 private void updatePositionProbability(int x, int y)
 {
     if (x < ((HeatMap.GetLength(0) - 1) / 2) && y < ((HeatMap.GetLength(1) - 1) / 2))
     {
         HeatMap[x + ((HeatMap.GetLength(0) - 1) / 2), y + ((HeatMap.GetLength(1) - 1) / 2)]++;
         IterationCount++;
     }
 }
Esempio n. 13
0
 private void Awake()
 {
     agentRef         = FindObjectOfType <BilliardAgent>();
     gameSystemRef    = FindObjectOfType <BilliardGameSystem>();
     heatmapRef       = FindObjectOfType <HeatMap>();
     trainerRef       = FindObjectOfType <TrainerMimic>();
     agentDecisionRef = agentRef.GetComponent <DecisionMAES>();
 }
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            Color c = HeatMap.ColorFromTemperature(5);

            Console.WriteLine(c);
        }
Esempio n. 15
0
        public void IntVector2AddLinearGradientEightWay()
        {
            var map = new HeatMap();

            map.AddLinearGradientEightWay(new IntVector2(0, 0), 10, 10, -1);
            map.AddLinearGradientEightWay(new IntVector2(1, 1), 2, 2, -1);
            Assert.AreEqual(11, map[0, 0]);
            Assert.AreEqual(11, map[1, 1]);
            Assert.AreEqual(0, map[99, 99]);
        }
Esempio n. 16
0
 public void CreateItem(HeatMap map)
 {
     Context.SaveAsync(map, (result) =>
     {
         if (result.Exception != null)
         {
             resultText.text += result.Exception.Message;
             return;
         }
     });
 }
Esempio n. 17
0
    public Playground()
    {
        initInputs();
        initDatasets();

        this.heatMap   = new HeatMap(DENSITY, xDomain, xDomain);
        this.lineChart = new Linechart(256, 128);

        generateData();
        reset();
    }
Esempio n. 18
0
        void ShowMatrix(float[][] M)
        {
            double[][] m = MathUtil.NewMatrix(M.Length, M[0].Length);
            for (int row = 0; row < M.Length; row++)
            {
                Array.Copy(M[row], m[row], M[0].Length);
            }
            var nt = NumberTable.CreateFromMatrix(m);
            var hm = new HeatMap(nt);

            Root.FormMgr.ShowForm(hm);
        }
Esempio n. 19
0
 public static IEnumerable <VectorTile> ToVectorTiles(this HeatMap tree, uint minZoom, uint maxZoom,
                                                      ToResolution?toResolution = null)
 {
     for (var z = minZoom; z <= maxZoom; z++)
     {
         var resolution = toResolution?.Invoke(z) ?? 256;
         foreach (var tile in tree.EnumerateTilesAt(z))
         {
             yield return(tree.GetVectorTile(tile, resolution));
         }
     }
 }
Esempio n. 20
0
        public List <HeatMapRegion> LoadHeatMapRegionsToTestWorkspace(string testWorkspaceName)
        {
            List <HeatMapRegion> heatMapRegions = new List <HeatMapRegion>();
            string workspaceResultsPath         = GetWorkspaceRandomExplorationResultsPath(testWorkspaceName);
            string heatMapRegionsFilePath       = workspaceResultsPath + RandomExplorationRun.heatMapRegionsFileName;

            if (!File.Exists(heatMapRegionsFilePath))
            {
                return(null);
            }
            string[]        heatMapRegionsFileLines = System.IO.File.ReadAllLines(heatMapRegionsFilePath);
            MatchCollection wordMatches             = Regex.Matches(heatMapRegionsFileLines[0], @"[^,]+");

            if (wordMatches.Count != (6 + 3 * 5))
            {
                return(null);
            }
            string[] objectiveFunctionsName = new string[5];
            for (int i = 0; i < 5; ++i)
            {
                objectiveFunctionsName[i] = wordMatches[6 + i * 3].Value;
            }
            HeatMap heatMap = new HeatMap();

            for (int l = 1; l < heatMapRegionsFileLines.Count(); ++l)
            {
                MatchCollection valueMatches = Regex.Matches(heatMapRegionsFileLines[l], @"[^,]+");
                if (valueMatches.Count != (6 + 3 * 5))
                {
                    return(null);
                }
                for (int i = 0; i < 5; ++i)
                {
                    HeatMapRegion heatMapRegion = new HeatMapRegion();
                    heatMapRegion.indexX          = Int16.Parse(valueMatches[0].Value);
                    heatMapRegion.indexY          = Int16.Parse(valueMatches[1].Value);
                    heatMapRegion.xStart          = float.Parse(valueMatches[2].Value);
                    heatMapRegion.xEnd            = float.Parse(valueMatches[3].Value);
                    heatMapRegion.yStart          = float.Parse(valueMatches[4].Value);
                    heatMapRegion.yEnd            = float.Parse(valueMatches[5].Value);
                    heatMapRegion.requirementName = objectiveFunctionsName[i];
                    HeatMapPoint heatMapPoint = new HeatMapPoint();
                    heatMapPoint.objectiveFunctionValues[heatMapRegion.requirementName] =
                        float.Parse(valueMatches[6 + i * 3].Value);
                    heatMapPoint.x = float.Parse(valueMatches[7 + i * 3].Value);
                    heatMapPoint.y = float.Parse(valueMatches[8 + i * 3].Value);
                    heatMapRegion.worstCasePointFromRandomExploration = heatMapPoint;
                    heatMapRegion.objectiveFunctionAverageValue       = heatMapPoint.objectiveFunctionValues[heatMapRegion.requirementName];
                    heatMapRegions.Add(heatMapRegion);
                }
            }
            return(heatMapRegions);
        }
 private void Awake()
 {
     agentRef         = FindObjectOfType <BilliardAgent>();
     gameSystemRef    = FindObjectOfType <BilliardGameSystem>();
     heatmapRef       = FindObjectOfType <HeatMap>();
     trainerRef       = FindObjectOfType <TrainerMimic>();
     agentDecisionRef = agentRef.GetComponent <DecisionMAES>();
     if (agentDecisionRef && agentDecisionRef.GetComponent <ESOptimizer>())
     {
         defaultMAESInitStep = agentDecisionRef.GetComponent <ESOptimizer>().initialStepSize;
     }
 }
 private void NormalizeResult()
 {
     if (HeatMap != null)
     {
         for (int l = 0; l < HeatMap.GetLength(0); l++)
         {
             for (int r = 0; r < HeatMap.GetLength(1); r++)
             {
                 HeatMap[l, r] = HeatMap[l, r] / IterationCount;
             }
         }
     }
 }
Esempio n. 23
0
    // Use this for initialization
    void Start()
    {
        // singleton-ish
        instance = this;

        // initialization
        colors  = new Color[resolution, resolution];
        texture = new Texture2D(resolution, resolution);
        GetComponent <Renderer>().material.mainTexture = texture;

        // start update loop
        StartCoroutine(UpdateFloor());
    }
Esempio n. 24
0
    // Use this for initialization
    protected virtual void Start()
    {
        this.gun    = new BasicGun(this);
        controller  = new BillController(this);
        leftOrRight = 0;
        health      = 3;

        billHealth = GameObject.Find("BillHealth").GetComponent <GUIText>();

        if (godMode)
        {
            health = 1000;
        }

        startingHeight = renderer.bounds.size.y;
        startingWidth  = renderer.bounds.size.x;

        if (Application.loadedLevelName == "Level_2")
        {
            leftBoundary  = 0.8f;
            rightBoundary = 0.8f;
        }

        Respawn();

        if (Application.loadedLevelName == "Level_1")
        {
            heatmap = GetComponent <HeatMap> ();

            string p_string = "Contra Bill Progresssion Level 1";
            string d_string = "Contra Bill Death Level 1";

            progressionTag = new HeatTag("p_string", url);
            progressionTag.SetSorted();
            progressionTag.MapPointColorDelta = ProgressionMapColorDelta;

            deathTag      = new HeatTag("d_string", url);
            deathTag.Type = HeatTag.HeatType.POINT;

            if (TrackPlayer)
            {
                heatmap.TrackPlayer(this.gameObject, progressionTag, 0.2f);
            }

            if (ShowHeatMap)
            {
                heatmap.PlotData(progressionTag);
                heatmap.PlotData(deathTag);
            }
        }
    }
Esempio n. 25
0
    void GetHeatmapFromText(string text)
    {
        // Debug.Log(text);
        string[] HeatMaps = text.Split('|');
        foreach (var HeatMap in HeatMaps)
        {
            string[] entries = HeatMap.Split('\n');

            foreach (var entry in entries)
            {
                if (entry != "")
                {
                    i = int.Parse(entry.Substring(1, 1));
                    if (entry.Substring(4, 1) == ")")
                    {
                        j     = int.Parse(entry.Substring(3, 1));
                        value = float.Parse(entry.Substring(6));
                    }
                    else
                    {
                        j     = int.Parse(entry.Substring(3, 2));
                        value = float.Parse(entry.Substring(7));
                    }

                    heatMapArray[i, j] += value;
                }
            }
        }
        for (int i = 0; i < heatMapArray.GetLength(0); i++)
        {
            for (int j = 0; j < heatMapArray.GetLength(1); j++)
            {
                if (highest < heatMapArray[i, j])
                {
                    highest = heatMapArray[i, j];
                }
            }
        }

        for (int i = 0; i < heatMapArray.GetLength(0); i++)
        {
            for (int j = 0; j < heatMapArray.GetLength(1); j++)
            {
                heatMapArray[i, j] = heatMapArray[i, j] / highest;
            }
        }
        control.instance.overAllHeatMap = heatMapArray;
    }
 private void DisplayHeatMap()
 {
     if (HeatMap != null)
     {
         Console.WriteLine("{0}x{1}", HeatMap.GetLength(0), HeatMap.GetLength(1));
         Console.WriteLine("");
         for (int l = 0; l < HeatMap.GetLength(0); l++)
         {
             for (int r = HeatMap.GetLength(1) - 1; r >= 0; r--)
             {
                 Console.Write("(" + HeatMap[l, r].ToString() + ") ");
             }
             Console.WriteLine("");
         }
     }
 }
Esempio n. 27
0
    public static Texture2D TextureFromHeatMap(HeatMap heatMap)
    {
        int width  = heatMap.values.GetLength(0);
        int height = heatMap.values.GetLength(1);

        Color[] colourMap = new Color[width * height];
        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                colourMap[y * width + x] = Color.Lerp(Color.black, Color.white, Mathf.InverseLerp(heatMap.minValue, heatMap.maxValue, heatMap.values[x, y]));
            }
        }

        return(TextureFromColourMap(colourMap, width, height));
    }
Esempio n. 28
0
        public IActionResult HeatMap()
        {
            ViewData["Title"]   = "HeatMap";
            ViewData["Message"] = "HeatMap en desarrollo... v.100";


            Data      pruebaBBDD    = new Data();
            DataTable myData        = pruebaBBDD.selectQuery("SELECT bssid, lat, lon, signal_rssi FROM SeenAp");
            HeatMap   customHeatMap = new HeatMap();

            foreach (DataRow row in myData.Rows)
            {
                customHeatMap.seenAPs.Add(new AccessPoint(row["bssid"].ToString(), row["lat"].ToString(), row["lon"].ToString(), row["signal_rssi"].ToString()));
            }

            return(View(customHeatMap));
        }
Esempio n. 29
0
        public static IEnumerable <(int x, int y, uint value)> GetValues(this HeatMap heatMap, ulong tileId, uint resolution = 256)
        {
            var(xTile, yTile, scaledResolution) = heatMap.GetTilePosition(tileId);

            if (scaledResolution < resolution)
            {
                throw new NotSupportedException("Upscaling of heatmap not supported.");
            }

            if (scaledResolution > resolution)
            {
                var factor = scaledResolution / resolution;
                for (var x = 0; x < resolution; x++)
                {
                    for (var y = 0; y < resolution; y++)
                    {
                        var xScaled = x * factor;
                        var yScaled = y * factor;
                        var count   = 0U;
                        for (var dx = 0; dx < factor; dx++)
                        {
                            for (var dy = 0; dy < factor; dy++)
                            {
                                count += heatMap[xTile + xScaled + dx, yTile + yScaled + dy];
                            }
                        }
                        if (count != 0)
                        {
                            yield return(x, y, count);
                        }
                    }
                }
            }

            for (var x = 0; x < resolution; x++)
            {
                for (var y = 0; y < resolution; y++)
                {
                    var count = heatMap[xTile + x, yTile + y];
                    if (count != 0)
                    {
                        yield return(x, y, count);
                    }
                }
            }
        }
Esempio n. 30
0
        public HeatMap LoadHeatMapDiagramToTestWorkspace(string testWorkspaceName)
        {
            string workspaceResultsPath    = GetWorkspaceRandomExplorationResultsPath(testWorkspaceName);
            string heatMapDiagramsFilePath = workspaceResultsPath + RandomExplorationRun.heatMapDiagramsFileName;

            if (!File.Exists(heatMapDiagramsFilePath))
            {
                return(null);
            }
            string[]        heatMapDiagramsFileLines = System.IO.File.ReadAllLines(heatMapDiagramsFilePath);
            MatchCollection wordMatches = Regex.Matches(heatMapDiagramsFileLines[0], @"[^,]+");

            if (wordMatches.Count != (4 + 5))
            {
                return(null);
            }
            string[] objectiveFunctionsName = new string[5];
            for (int i = 0; i < 5; ++i)
            {
                objectiveFunctionsName[i] = wordMatches[i + 4].Value;
            }
            HeatMap heatMap = new HeatMap();

            for (int l = 1; l < heatMapDiagramsFileLines.Count(); ++l)
            {
                MatchCollection valueMatches = Regex.Matches(heatMapDiagramsFileLines[l], @"[^,]+");
                if (valueMatches.Count != (4 + 5))
                {
                    return(null);
                }
                HeatMapPoint heatMapPoint = new HeatMapPoint();
                heatMapPoint.indexX = Int16.Parse(valueMatches[0].Value);
                heatMapPoint.indexY = Int16.Parse(valueMatches[1].Value);
                heatMapPoint.x      = float.Parse(valueMatches[2].Value);
                heatMapPoint.y      = float.Parse(valueMatches[3].Value);
                for (int i = 4; i < valueMatches.Count; ++i)
                {
                    heatMapPoint.objectiveFunctionValues.Add(objectiveFunctionsName[i - 4],
                                                             float.Parse(valueMatches[i].Value));
                }
                heatMap.AddPoint(heatMapPoint);
            }
            heatMap.FinalizeAddingPoints();
            return(heatMap);
        }