private void DrawGlobalHeatmap() { var state = _gameInstance.State; var mouseMob = state.AtCoord(_camera.MouseHex, true); var heatmap = Heatmap.BuildHeatmap(_gameInstance, mouseMob); DrawHeatmap(heatmap); }
/// <summary> /// initialization. /// </summary> void Start() { //Get Server Instance if (serverInstance == null) { serverInstance = TCPServer.getInstance(Ip, Port); } //register to IncomingMessage event serverInstance.incomingMessage += new EventIncomingMessage(HandleIncomingMessage); //Get Animator if (MainArm == null) { MainArm = GameObject.FindGameObjectWithTag("MainLimbAnimatorObject"); } animArm = MainArm.GetComponent <Animator>(); if (TACArm == null) { TACArm = GameObject.FindGameObjectWithTag("TACLimbAnimatorObject"); } if (TACArm != null) { animTACArm = TACArm.GetComponent <Animator>(); } TACArm.GetComponentInChildren <SkinnedMeshRenderer>().enabled = !HideTACArm; TACArmSkinR = false; //Create Mam Mam = new Heatmap(colormap, alpha, cubeheight, map3D, MainArm); //Set DOF LIST for main Arm DOF_ArmList.Add(new DOF("f_Open", "f_Close", 0x09, -1.0F, 1.0F, Range)); DOF_ArmList.Add(new DOF("f_Supination", "f_Pronation", 0x08, -1.0F, 1.0F, Range)); DOF_ArmList.Add(new DOF("f_Extend", "f_Flex", 0x07, -1.0F, 1.0F, Range)); DOF_ArmList.Add(new DOF("f_Ulnar", "f_Radial", 0x0F, 0.0F, 1.0F, Range)); //minValue is 0 because a fully extended arm is the initial position. The currentValue cannot go <0 and cause some delay when flexing again. DOF_ArmList.Add(new DOF("f_Pincer", "f_Rest", 0x0C, 0.0F, 1.0F, Range)); DOF_ArmList.Add(new DOF("f_IndexFinger", "f_Rest", 0x0A, 0.0F, 1.0F, Range)); DOF_ArmList.Add(new DOF("f_Key", "f_Rest", 0x0D, 0.0F, 1.0F, Range)); DOF_ArmList.Add(new DOF("f_Rest", "f_Rest", 0x00, 0.0F, 0.0F, Range)); //Set DOF LIST for the TAC Arm DOF_TAC_ArmList.Add(new DOF("f_Open", "f_Close", 0x09, -1.0F, 1.0F, Range)); DOF_TAC_ArmList.Add(new DOF("f_Supination", "f_Pronation", 0x08, -1.0F, 1.0F, Range)); DOF_TAC_ArmList.Add(new DOF("f_Extend", "f_Flex", 0x07, -1.0F, 1.0F, Range)); DOF_TAC_ArmList.Add(new DOF("f_Ulnar", "f_Radial", 0x0F, 0.0F, 1.0F, Range)); DOF_TAC_ArmList.Add(new DOF("f_Pincer", "f_Rest", 0x0C, 0.0F, 1.0F, Range)); DOF_TAC_ArmList.Add(new DOF("f_IndexFinger", "f_Rest", 0x0A, 0.0F, 1.0F, Range)); DOF_TAC_ArmList.Add(new DOF("f_Key", "f_Rest", 0x0D, 0.0F, 1.0F, Range)); DOF_TAC_ArmList.Add(new DOF("f_Rest", "f_Rest", 0x00, 0.0F, 0.0F, Range)); //Set ID-list of secondary-close movments CloseMovement.Add(0x0C); CloseMovement.Add(0x0D); CloseMovement.Add(0x0A); }
private void GenerateHeatmap(string filename) { if (cyclists == null) { cyclists = new AssetType[1]; cyclists[0] = AssetType.Cyclist; } if (area == null) { Debug.LogError("Can't generate heatmap with unassigned area"); return; } Bounds aabb = new Bounds(area.position, area.localScale); if (filename.EndsWith(TrafficIO.VISSIM_VEHICLES_EXTENSION)) { TrafficData data = TrafficIO.Load(filename, columnSeparator, vectorSeparator, true); if (data == null) { return; } Heatmap.GenerateHeatmap(data, trafficMgr.transform.position, resolution, pointSize * 0.5f, aabb, logarithmic, "Vehicles_Heatmap", cyclists, false); Heatmap.GenerateHeatmap(data, trafficMgr.transform.position, resolution, pointSize * 0.5f, aabb, logarithmic, "Cyclists_Heatmap", cyclists, true); } else if (filename.EndsWith(TrafficIO.VISSIM_PEDESTRIANS_EXTENSION)) { TrafficData data = TrafficIO.Load(filename, columnSeparator, vectorSeparator, true); if (data == null) { return; } Heatmap.GenerateHeatmap(data, trafficMgr.transform.position, resolution, pointSize * 0.5f, aabb, logarithmic, "Pedestrians_Heatmap"); } else if (filename.EndsWith(TrafficIO.BINARY_VEHICLES_EXTENSION)) { TrafficData data = TrafficIO.LoadBinary(filename, true); if (data == null) { return; } Heatmap.GenerateHeatmap(data, trafficMgr.transform.position, resolution, pointSize * 0.5f, aabb, logarithmic, "Vehicles_Heatmap", cyclists, false); Heatmap.GenerateHeatmap(data, trafficMgr.transform.position, resolution, pointSize * 0.5f, aabb, logarithmic, "Cyclists_Heatmap", cyclists, true); } else if (filename.EndsWith(TrafficIO.BINARY_PEDESTRIANS_EXTENSION)) { TrafficData data = TrafficIO.LoadBinary(filename, true); if (data == null) { return; } Heatmap.GenerateHeatmap(data, trafficMgr.transform.position, resolution, pointSize * 0.5f, aabb, logarithmic, "Pedestrians_Heatmap"); } AssetDatabase.Refresh(); }
public async Task <IActionResult> Post(Heatmap heatmap) { Heatmap _heatmap = await _heatmapService.AddAsync(heatmap); if (_heatmap == null) { return(NotFound()); } return(CreatedAtAction(nameof(Get), _heatmap)); }
public async Task <ActionResult <Heatmap> > Get(int heatmapId) { Heatmap heatmap = await _heatmapService.GetByIdAsync(heatmapId); if (heatmap == null) { return(NotFound()); } return(heatmap); }
/// <summary> /// Add a colorbar initialized with settings from a heatmap /// </summary> public Colorbar AddColorbar(Heatmap heatmap, int space = 100) { var cb = new Colorbar(heatmap.Colormap); cb.AddTick(0, heatmap.ColorbarMin); cb.AddTick(1, heatmap.ColorbarMax); Add(cb); YAxis2.SetSizeLimit(min: space); return(cb); }
public async Task <IActionResult> Put(int heatmapId, Heatmap heatmap) { if (heatmapId != heatmap.HeatmapID) { return(BadRequest()); } await _heatmapService.UpdateAsync(heatmap); return(NoContent()); }
public virtual void OnHeatMapWayPoint(int id, Heatmap heatMap) { var handler = OnHeatMapWayPointEvent; if (handler != null) { handler(this, new HeatMapArgs { RobotId = id, HeatMap = heatMap }); } }
private void Awake() { start_panel_active = true; buildingDeleteModeOn = false; barDeleteModeOn = false; landmarkModeOn = false; buildingPlacement = GameObject.Find("Terrain").GetComponent <BuildingPlacement>(); barPlacement = GameObject.Find("Terrain").GetComponent <BarPlacement>(); skyExposure = GameObject.Find("Main Camera").GetComponent <SkyExposure>(); heatmap = GameObject.Find("Heatmap").GetComponent <Heatmap>(); create_building_panel.SetActive(false); }
static async Task Main() { // Call asynchronous network methods in a try/catch block to handle exceptions. try { client.DefaultRequestHeaders.Add("ApiKey", "829320-adajdasd-12vasdas-baslk3"); HttpResponseMessage response = await client.GetAsync("https://fruitflywebapi.azurewebsites.net/api/Referencepoint"); response.EnsureSuccessStatusCode(); string responseBody = await response.Content.ReadAsStringAsync(); // Above three lines can be replaced with new helper method below //Splits the responsebody into each datatype and it's value. Items * 1000 to make sure that a thousand heatmapID's can be loaded. line = responseBody.Split(',', items * 1000); //Checks for 3 specific strings that contain: 'x', 'y' and ('h', 'e', 'a' and 't'). CheckEachString(); for (int i = 0; i < lineHeat.Count; i++) { //Here a new object of heatmap is created for each heatmap ID in the database. The values are collected from the sepereate list of x, y and heatmapID. var obj = new Heatmap { x = ExtractInteger(lineX[i]), y = ExtractInteger(lineY[i]), HeatmapID = ExtractInteger(lineHeat[i]), Value = 1 }; //adds all the added headmaps into a list of heatmaps. heatmaps.Add(obj); } //compares if there are more than 1 element with the same x and y coordinates. If so, the value of the item will increase with 1 pr matching elements. CompareElements(heatmaps); foreach (var i in heatmaps) { Console.WriteLine("X: " + i.x + "\t" + "Y: " + i.y + "\t" + "Value: " + i.Value + "\t" + "ID: " + i.HeatmapID + "\n"); } //serializes the list of heatmaps and JsonSerialize(heatmaps); } catch (HttpRequestException e) { Console.WriteLine("\nException Caught!"); Console.WriteLine("Message :{0} ", e.Message); } }
public async Task <IActionResult> Delete(int heatmapId) { Heatmap heatmap = await _heatmapService.GetByIdAsync(heatmapId); if (heatmap == null) { return(NotFound()); } await _heatmapService.RemoveAsync(heatmap); return(NoContent()); }
public async Task <IEnumerable <Heatmap> > GetAllHeatmapAsync() { // Call asynchronous network methods in a try/catch block to handle exceptions. try { HeatClient.DefaultRequestHeaders.Add("ApiKey", "829320-adajdasd-12vasdas-baslk3"); //Server side API Token var handler = _httpHandler.Get("https://fruitflywebapi.azurewebsites.net/api/Heatmap", HeatClient).EnsureSuccessStatusCode(); if (handler.IsSuccessStatusCode) { var responseBody = await handler.Content.ReadAsStringAsync(); Console.WriteLine("Connection established"); //Splits the responsebody into each datatype and it's value. Items * 1000 to make sure that a thousand heatmapID's can be loaded. var _line = responseBody.Split(',', items * 1000); //Checks for 3 specific strings that contain: 'x', 'y' and ('h', 'e', 'a' and 't'). CheckEachString.CheckStringHeatmap(_line, LineX, LineY, LineHeat); for (int i = 0; i < LineHeat.Count; i++) { //Here a new object of heatmap is created for each heatmap ID in the database. The values are collected from the sepereate list of x, y and heatmapID. var obj = new Heatmap { x = Extractor.ExtractFromString(LineX[i]), y = Extractor.ExtractFromString(LineY[i]), HeatmapID = Extractor.ExtractFromString(LineHeat[i]), Value = 1 }; //adds all the added heatmaps into a list of heatmaps. Heatmaps.Add(obj); } //compares if there are more than 1 element with the same x and y coordinates. If so, the value of the item will increase with 1 pr matching elements. CompareElements.CompareHeatmapValues(Heatmaps); } } catch (HttpRequestException e) { Console.WriteLine("\nException Caught!"); Console.WriteLine("Message :{0} ", e.Message); } //DeleteAllHeatmapAsync(); //returns all data stored in the list of heatmaps to the GET method Console.WriteLine("All heatmap data stored"); return(Heatmaps); }
private void Save(string filename, Heatmap heatmap) { // Serializes the heatmap data and saves the data to the given path (and overwrites if necessary) StreamWriter streamWriter = new StreamWriter("Assets/Resources/Heatmap/" + filename + ".txt", false); streamWriter.Write(Json.Serialize(heatmap.Data)); streamWriter.Close(); // Reimports the file because Unity doesn't realize changes made to it AssetDatabase.ImportAsset("Assets/Resources/Heatmap/" + filename + ".txt"); HeatmapFilename = filename; }
public IEnumerator TakeScreenshot() { int i = 0; while (File.Exists("Assets/Screenshot" + i + ".png")) { i++; yield return(0); } string path = "Assets/Screenshot" + i + ".png"; Heatmap.Screenshot(path, camera); }
public void Recived_calls_JsonSerializer() { List <Heatmap> heatmaps = new List <Heatmap>(); Heatmap h = new Heatmap(); heatmaps.Add(h); var mockedObject = new Mock <IController>(); var obj = mockedObject.Object; obj.OpenConnection(); Mock.Get(obj).Verify(x => x.JsonSerialize(heatmaps), Times.AtLeastOnce); }
/// <summary> /// Add a heatmap to the plot /// </summary> public Heatmap AddHeatmap(double[,] intensities, Drawing.Colormap colormap = null, bool lockScales = true) { if (lockScales) { AxisScaleLock(true); } var plottable = new Heatmap(); plottable.Update(intensities, colormap); Add(plottable); return(plottable); }
public void RiderStart() { m_heatmap = GetComponent <Heatmap>(); m_steering = GetComponent <Steering>(); m_game = FindObjectOfType <BikeGangs>(); m_started = true; m_moveSpeed = Random.Range(MinMoveSpeed, MaxMoveSpeed); m_offset = Random.Range(-m_game.RoadGenerator.RoadWidth, m_game.RoadGenerator.RoadWidth); m_targetOffset = m_game.RoadGenerator.RoadWidth / 12.0f * 3.0f; m_heatmap.Begin(); m_accumulatorMultiplier = Random.Range(0.0f, 10.0f); m_accumulatorMultiplier += Random.Range(0.0f, 0.5f); }
private XPlot.Plotly.PlotlyChart PlotMatrix(double[,] matrix) { var m = matrix.Reverse(false); var s1 = new Heatmap() { name = "Heat-map of Matrix", colorscale = @"YIGnBu", z = m }; var chart = XPlot.Plotly.Chart.Plot <Trace>(new Trace[] { s1 }); return(chart); }
private void ChartLoaded(object sender, RoutedEventArgs e) { if (chart.Series.Count > 0) { return; } chart.BeginUpdate(); var scale = new DiscreteColorScale() { Intervals = new List <DiscreteColorScale.Interval>() }; scale.Intervals.Add(new DiscreteColorScale.Interval(0, 10, Color.FromRgb(0x05, 0x71, 0xB0), "Very Low")); scale.Intervals.Add(new DiscreteColorScale.Interval(10, 25, Color.FromRgb(0x92, 0xC5, 0xDE), "Low")); scale.Intervals.Add(new DiscreteColorScale.Interval(25, 75, Color.FromRgb(0xD7, 0xD7, 0xD7), "Normal")); scale.Intervals.Add(new DiscreteColorScale.Interval(75, 90, Color.FromRgb(0xF4, 0xA5, 0x82), "High")); scale.Intervals.Add(new DiscreteColorScale.Interval(90, 100, Color.FromRgb(0xCA, 0x00, 0x20), "Critical")); var rnd = new Random(); var data = new double[24, 7]; for (var j = 0; j < 7; j++) { for (var i = 0; i < 24; i++) { data[i, j] = 10 * Math.Exp(-(i - 12) * (i - 12) / (2 * 4.0 * 4.0)) / Math.Sqrt(2 * Math.PI * 4.0 * 4.0) * ((j == 5 || j == 6) ? 50 : 100) * rnd.NextDouble(); } } var hmap = new Heatmap(); hmap.ItemsSource = data; hmap.ColorScale = scale; chart.Series.Add(hmap); var times = new string[24]; for (var i = 0; i < 24; i++) { times[i] = new DateTime(2000, 1, 1, i, 0, 0).ToShortTimeString(); } chart.AxisX.ItemsSource = times; chart.AxisY.ItemsSource = new string[] { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" }; chart.EndUpdate(); }
private void DrawHoverHeatmap(int currentMob) { if (_gameInstance.Pathfinder.IsValidCoord(_camera.MouseHex)) { var state = _gameInstance.State; var mouseMob = state.AtCoord(_camera.MouseHex, true); if (mouseMob.HasValue) { var heatmap = Heatmap.BuildHeatmap(_gameInstance, mouseMob); DrawHeatmap(heatmap); } } }
private void DrawHeatmap(Heatmap heatmap) { _spriteBatch.Begin(transformMatrix: _camera.Transform, samplerState: Camera2D.SamplerState); foreach (var coord in heatmap.Map.AllCoords) { if (heatmap.Map[coord] == 0) { continue; } float percent = heatmap.Map[coord] / (float)heatmap.MaxValue / 2 + 0.5f; DrawAt(_assetManager[AssetManager.HexHoverSprite], coord, Color.Red * percent * percent); } _spriteBatch.End(); }
private void ColorAxis_Load(object sender, EventArgs e) { var chart = new FlexChart(); chart.Legend.Position = Position.None; chart.Dock = DockStyle.Fill; chart.AxisY.Title = "y"; chart.AxisY.MajorGrid = false; chart.AxisY.AxisLine = true; chart.AxisY.MajorTickMarks = TickMark.Outside; chart.AxisX.Title = "x"; chart.ToolTip.Content = "{item:0.00}"; chart.Header.Content = "2D deformation distribution"; chart.Header.Style.Font = new Font("Seqoe UI", 16); var scale = new GradientColorScale() { Min = 0, Max = 4, Axis = new C1.Win.Chart.Extended.ColorAxis() { Position = Position.Right, Title = "deformation, mm" }, Colors = new List <Color> { Color.Yellow, Color.Red } }; var data = new double[150, 150]; for (var i = 0; i < 150; i++) { for (var j = 0; j < 150; j++) { data[i, j] = 2 + (Math.Sin(0.01 * i) + Math.Cos(0.1 * j)); } } var hmap = new Heatmap(); hmap.DataSource = data; hmap.ColorScale = scale; hmap.StartX = 0; hmap.StartY = 0; chart.Series.Add(hmap); Controls.Add(chart); }
void GenerateHeatMap() { Bounds aabb = new Bounds(area.position, area.localScale); if (heatmapPasses == null || heatmapPasses.Length == 0) { Heatmap.GenerateHeatmap(data, transform.position, heatmapResolution, pointRadius, aabb, logarithmic, name + "-Heatmap"); } else { for (int i = 0; i < heatmapPasses.Length; i++) { Heatmap.GenerateHeatmap(data, transform.position, heatmapResolution, pointRadius, aabb, logarithmic, name + "-Heatmap" + (i + 1), heatmapPasses[i].assetTypes, heatmapPasses[i].include); } } }
void Awake() { gvc = GetComponentInChildren <GraphicValuesController> (); heatmap = FindObjectOfType <Heatmap> (); HeatmapActive = false; //Persistencia de IP y Puerto //ipText.text = PlayerPrefs.GetString("IP"); //portText.text = PlayerPrefs.GetString("Port"); try{ dataObjectUI = FindObjectOfType <DataObject>().gameObject; }catch { throw new System.IndexOutOfRangeException("No hay ningún DataObject en la escena!"); } }
public async Task <IEnumerable <Heatmap> > GetAllReferenceid() { try { RefClient.DefaultRequestHeaders.Add("ApiKey", "829320-adajdasd-12vasdas-baslk3"); //Server side API Token var handler = _httpHandler.Get("https://fruitflywebapi.azurewebsites.net/api/Referencepoint", RefClient).EnsureSuccessStatusCode(); if (handler.IsSuccessStatusCode) { Console.WriteLine("Connection established"); var responseBody = await handler.Content.ReadAsStringAsync(); //Splits the responsebody into each datatype and it's value. Items * 1000 to make sure that a thousand heatmapID's can be loaded. var _line = responseBody.Split(',', items * 1000); //Checks for 3 specific strings that contain: 'x', 'y' and ('r', 'e', and 'f'). CheckEachString.CheckStringReference(_line, RefLineX, RefLineY, LineRef); for (int i = 0; i < LineRef.Count; i++) { //Here a new object of heatmap is created for each heatmap ID in the database. The values are collected from the sepereate list of x, y and heatmapID. var obj = new Heatmap { x = Extractor.ExtractFromString(RefLineX[i]), y = Extractor.ExtractFromString(RefLineY[i]), HeatmapID = Extractor.ExtractFromString(LineRef[i]), Value = 0 }; //adds all the added heatmaps into a list of heatmaps. HeatmapsRef.Add(obj); } } } catch (HttpRequestException e) { Console.WriteLine("\nException Caught!"); Console.WriteLine("Message :{0} ", e.Message); } //returns all data stored in the list of heatmaps to the GET method Console.WriteLine("All Reference data stored"); return(HeatmapsRef); }
public void Setup() { uut = new CompareElements(); items = new List <Heatmap>(); Heatmap h1 = new Heatmap { x = 3, y = 4, Value = 1, HeatmapID = 1 }; Heatmap h2 = new Heatmap { x = 42, y = 62, Value = 1, HeatmapID = 2 }; Heatmap h3 = new Heatmap { x = 32, y = 3, Value = 1, HeatmapID = 3 }; Heatmap h4 = new Heatmap { x = 17, y = 55, Value = 1, HeatmapID = 4 }; Heatmap h5 = new Heatmap { x = 3, y = 4, Value = 1, HeatmapID = 5 }; items.Add(h1); items.Add(h2); items.Add(h3); items.Add(h4); items.Add(h5); }
public static bool CanSeeGridRay(Vec2I from, Vec2I to) { foreach (Vec2I step in AxMath.CartesianLine(from, to)) { HeatmapNode node = Heatmap.GetNode(step); if (node == null) { return(false); } if (node.HasWall) { return(false); } } return(true); }
/// <summary> /// Generates a number of defensive move actions based on a heatmap. /// </summary> public static void GenerateDefensiveMoveActions(GameInstance state, CachedMob mob, List <UctAction> result) { var heatmap = Heatmap.BuildHeatmap(state, null, false); var coords = new List <AxialCoord>(); var mobInstance = mob.MobInstance; var mobId = mob.MobId; foreach (var coord in heatmap.Map.AllCoords) { if (heatmap.Map[coord] != heatmap.MinValue) { continue; } if (state.Map[coord] == HexType.Wall) { continue; } if (state.State.AtCoord(coord, true).HasValue) { continue; } bool canMoveTo = state.Pathfinder.Distance(mobInstance.Coord, coord) <= mobInstance.Ap; if (!canMoveTo) { continue; } coords.Add(coord); } coords.Shuffle(); int maximumMoveActions = Math.Max(0, 3 - result.Count); for (int i = 0; i < Math.Min(coords.Count, maximumMoveActions); i++) { var action = UctAction.DefensiveMoveAction(mobId, coords[i]); GameInvariants.AssertValidAction(state, action); result.Add(action); } }
public void OnGUI() { if (GUI.Button(resetRect, "Reset")) { Heatmap.DestroyHeatmapObjects(); ClearPoints(); #if !UNITY_WEBPLAYER //usePresetCoordinates = false; #endif } #if !UNITY_WEBPLAYER if (GUI.Button(screenshotRect, "Screenshot")) { StartCoroutine(TakeScreenshot()); } #endif }
public static int MINIMUM_THRESHOLD = -333; //!< Minimum threshold. /// Minimum alpha a point must have to be rendered at all. /// //Inputs: speedAndPos | the dictionary that stores all the points and their different color values // cam | the main camera // plane | the heatplane that the texture is going to be put on //Outputs: Texture2D | the texture that the heatmap is put on //Functionality: creates a texture for the heatmap to be stored on using all the points and their color values public static Texture2D CreateHeatmap(Dictionary <Vector2, float> speedAndPos, Camera cam, GameObject plane) { //find camera if (cam == null) { if (Camera.main == null) { Debug.LogWarning("No camera found. Returning an empty texture."); return(new Texture2D(0, 0)); } else { cam = Camera.main; } } // Create new texture Texture2D map = new Texture2D((int)(plane.transform.localScale.x * 30 * 10), (int)(plane.transform.localScale.z * 30 * 10), TextureFormat.ARGB32, false); // Set texture to alpha-fied state map.SetPixels(Heatmap.ColorArray(new Color(1f, 1f, 1f, 0f), map.width * map.height), 0); //Going through each point, set the alpha value to the color value in speedAndPos foreach (KeyValuePair <Vector2, float> keyval in speedAndPos) { //this checks if the color value is 0, in which case the color should be different. This represents the starting position of the agent //this is currently turned off in Tracker if (keyval.Value == 0) { map.SetPixel((int)keyval.Key.x, (int)keyval.Key.y, Color.cyan); } else { map.SetPixel((int)keyval.Key.x, (int)keyval.Key.y, new Color(1f, 1f, 1f, keyval.Value)); } } //finish the map by applying all changes and setting the rest of the pixels map.Apply(); map.SetPixels(Colorize(map.GetPixels(0)), 0); map.Apply(); return(map); }
private bool SaveAs(string filename, Heatmap heatmap, ref bool shouldRebuild) { TextAsset textAsset = Resources.Load<TextAsset>("Heatmap/" + filename); // Does the same thing as above, but asks if you want to overwrite the file in case it already exists if ((textAsset == null) || EditorUtility.DisplayDialog("Warning", "That file already exists, do you want to overwrite it?", "Yes", "No")) { if (shouldRebuild) { heatmap.RefreshData(); shouldRebuild = false; } Save(filename, heatmap); // Also, assigns the file to the heatmap heatmap.File = Resources.Load<TextAsset>("Heatmap/" + filename); Task = HeatmapEditorTask.ViewOrUpdate; return true; } return false; }