public override IEnumerator LoadData(PatchLoadedCallback callback)
{
bool loaded = false;
yield return(multigrid.LoadBin(Filename, (g) => loaded = true));
if (loaded)
{
foreach (var c in multigrid.categories)
{
var grid = c.grid;
if (grid.minFilter == 0 && grid.maxFilter == 0)
{
grid.minFilter = Mathf.Max(0.5f, grid.minValue);
grid.maxFilter = grid.maxValue;
}
}
GridPatch.AssignCategoryColors(multigrid.categories, DataLayer.Color, multigrid.coloring);
multigrid.GridChanged();
callback(this);
}
}
public GridPatch CreateGridPatch(string siteName, int level, int year, GridData data)
{
var newPatch = new GridPatch(this, level, year, data, null);
OnPatchCreated(newPatch, siteName);
return(newPatch);
}
//
// Public Method
//
public void Init(GraphPatch networkPatch, GridPatch reachabilityPatch, float[] minutesPerMeter, float travelTime)
{
this.networkPatch = networkPatch;
this.reachabilityPatch = reachabilityPatch;
this.map = ComponentManager.Instance.Get <MapController>();
SetMinutesPerMeter(minutesPerMeter);
SetTravelTime(travelTime);
}
private void OnPatchVisibilityChange(DataLayer dataLayer, Patch patch, bool visible)
{
if (dataLayer.Name == networkLayerName)
{
if (visible)
{
SetNetworkPatch(patch as GraphPatch);
}
else if (patch == networkPatch)
{
SetNetworkPatch(null);
}
}
else if (dataLayer.Name == reachabilityLayerName)
{
if (visible)
{
reachabilityPatch = patch as GridPatch;
GridMapLayer mapLayer = reachabilityPatch.GetMapLayer() as GridMapLayer;
if (mapLayer != null)
{
mapLayer.SetStripes(stripeCount, true);
}
if (reachabilityPatch.grid.IsCategorized)
{
ShowError(CategorizedReachabilityError);
ResetTool(true);
return;
}
else if (placeStart != null)
{
placeStart.ReachabilityPatch = reachabilityPatch;
}
}
else if (patch == reachabilityPatch)
{
reachabilityPatch = null;
}
}
if (networkPatch == null)
{
ShowError(NetworkNotAvailableHereError);
movedAwayError = true;
}
else if (movedAwayError)
{
movedAwayError = false;
HideErrorMessage();
}
}
private void CreateReachabilityPatch(GraphPatch graphPatch)
{
GridData grid = new GridData(graphPatch.grid, false);
grid.InitGridValues();
grid.minValue = 0;
grid.maxValue = traveTimeSlider.value * travelTimeScale;
grid.minFilter = grid.maxFilter = 0;
grid.metadata = null;
reachabilityPatch = reachabilityLayer.CreateGridPatch(graphPatch.GetSiteName(), graphPatch.Level, DateTime.Now.Year, grid);
dataLayers.UpdateLayer(reachabilityLayer);
}
private void ResetTool(bool turnOff)
{
editSpeedToggle.isOn = false;
// Disable layers visibility event
dataLayers.OnLayerVisibilityChange -= OnLayerVisibilityChange;
// Clear layers dropdown
if (!turnOff)
{
layerDropdown.ClearOptions();
}
ClearAllUserChanges();
// Deactivate layers
if (networkLayer != null)
{
// Disable patches visibility events
networkLayer.OnPatchVisibilityChange -= OnPatchVisibilityChange;
if (turnOff && dataLayers.IsLayerActive(networkLayer))
{
dataLayers.ActivateLayer(networkLayer, false);
}
}
if (reachabilityLayer != null)
{
reachabilityLayer.OnPatchVisibilityChange -= OnPatchVisibilityChange;
if (turnOff && dataLayers.IsLayerActive(reachabilityLayer))
{
dataLayers.ActivateLayer(reachabilityLayer, false);
}
}
newRoadPanel.SetActive(false);
mainPanel.SetActive(true);
// Reset path references
networkPatch = null;
reachabilityPatch = null;
ResetErrorMessage();
movedAwayError = false;
deactivatedLayerError = false;
// Re-enable layers visibility event
dataLayers.OnLayerVisibilityChange += OnLayerVisibilityChange;
}
private void _UpdateChart()
{
nextValidUpdateTime = Time.time + ChartUpdateInterval;
ClearChartValues();
float minValue = float.MaxValue;
float maxValue = float.MinValue;
float minRange;
float maxRange;
float minVal = (filterValsInPercent) ? siteMinPercent : siteMinValue;
float maxVal = (filterValsInPercent) ? siteMaxPercent : siteMaxValue;
for (int i = 0; i < dataLayer.loadedPatchesInView.Count; i++)
{
GridPatch patch = dataLayer.loadedPatchesInView[i] as GridPatch;
if (patch == null)
{
continue;
}
var grid = patch.grid;
if (grid.minValue != float.MaxValue)
{
minValue = Mathf.Min(minValue, grid.minValue);
maxValue = Mathf.Max(maxValue, grid.maxValue);
minRange = Mathf.InverseLerp(minVal, maxVal, grid.minValue);
maxRange = Mathf.InverseLerp(minVal, maxVal, grid.maxValue);
}
else
{
minValue = 0;
maxValue = 0;
minRange = 0;
maxRange = 0;
}
var dv = grid.DistributionValues;
int distribSize = 0;
if (dv != null)
{
distribSize = dv.Length;
}
float invSize = 1f / distribSize;
float f1 = minRange * chartSize;
int ci1 = (int)f1;
float f2;
int ci2;
float countPerChartSlot = distribSize / ((maxRange - minRange) * chartSize);
for (int j = 1; j <= distribSize; j++)
{
f2 = chartSize * Mathf.Lerp(minRange, maxRange, j * invSize);
ci2 = (int)f2;
if (ci1 == ci2)
{
chartValues[ci1] += dv[j - 1];
maxChartValue = Mathf.Max(maxChartValue, chartValues[ci1]);
}
else
{
float x = dv[j - 1] * countPerChartSlot;
float p = ci1 - f1 + 1f;
chartValues[ci1] += p * x;
maxChartValue = Mathf.Max(maxChartValue, chartValues[ci1]);
for (int ci = ci1 + 1; ci < ci2; ci++)
{
chartValues[ci] += x;
maxChartValue = Mathf.Max(maxChartValue, chartValues[ci]);
}
if (ci2 < chartSize)
{
p = f2 - ci2;
chartValues[ci2] += p * x;
maxChartValue = Mathf.Max(maxChartValue, chartValues[ci2]);
}
}
f1 = f2;
ci1 = ci2;
}
}
chart.SetMinRange(Mathf.InverseLerp(minVal, maxVal, minValue));
chart.SetMaxRange(Mathf.InverseLerp(minVal, maxVal, maxValue));
chart.SetData(chartValues, maxChartValue);
}
