public static void SaveBin(this MultiGridData multigrid, string filename)
{
using (var bw = new BinaryWriter(File.Open(filename, FileMode.Create)))
{
PatchDataIO.WriteBinVersion(bw);
PatchDataIO.WriteBinBoundsHeader(bw, multigrid);
// Write Metadata (if available)
PatchDataIO.WriteBinMetadata(bw, multigrid.metadata);
bw.Write((byte)multigrid.coloring);
int categoriesCount = multigrid.categories == null ? 0 : multigrid.categories.Length;
bw.Write(categoriesCount);
if (multigrid.categories != null)
{
// Write categories (without values)
foreach (var c in multigrid.categories)
{
bw.Write(c.name);
}
// Write Grids
foreach (var c in multigrid.categories)
{
GridDataIO.WriteBinProperties(bw, c.grid);
GridDataIO.WriteBinValues(bw, c.grid);
}
}
}
}
private static MultiGridData ParseBin(BinaryReader br, string filename, MultiGridData multigrid)
{
ParseBinHeader(br, filename, multigrid);
ParseBinProperties(br, multigrid);
ParseBinGrids(br, filename, multigrid);
return(multigrid);
}
public static MultiGridData ParseBinHeader(BinaryReader br, string filename, MultiGridData multigrid)
{
// Read header
PatchDataIO.SkipBinVersion(br);
PatchDataIO.ReadBinBoundsHeader(br, filename, multigrid);
return(multigrid);
}
private MultiGridData QuickReadMultiGridPatch(string filename)
{
var data = new MultiGridData();
using (var br = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
MultiGridDataIO.ParseBinHeader(br, filename, data);
MultiGridDataIO.ParseBinProperties(br, data);
}
return(data);
}
private void CreateMultiGridMapLayer(MultiGridData multigrid)
{
int count = multigrid.categories.Length;
for (int i = 0; i < count; i++)
{
if (multigrid.gridFilter.IsSet(i))
{
CreateGridMapLayer(multigrid.categories[i].grid);
// Change the map layer's color to the category's one (by default it will have the datalayer's color)
visibleGrids[visibleGrids.Count - 1].SetColor(multigrid.categories[i].color);
}
}
}
public static void ParseBinGrids(BinaryReader br, string filename, MultiGridData multigrid)
{
if (multigrid.categories != null)
{
int count = multigrid.categories.Length;
for (int i = 0; i < count; i++)
{
var grid = new GridData(multigrid);
GridDataIO.ParseBinProperties(br, filename, grid);
GridDataIO.ParseBinValues(br, grid);
grid.patch = multigrid.patch;
multigrid.categories[i].grid = grid;
}
}
}
public MultiGridData(MultiGridData other, bool withValues = true) : base(other)
{
if (other.categories != null)
{
int count = other.categories.Length;
categories = new GridCategory[other.categories.Length];
for (int i = 0; i < count; i++)
{
var c = other.categories[i];
var category = new GridCategory(c.name, new GridData(c.grid, withValues), c.color);
category.grid.patch = patch;
categories[i] = category;
}
}
gridFilter = other.gridFilter;
coloring = other.coloring;
}
public static void ParseBinProperties(BinaryReader br, MultiGridData multigrid)
{
// Read Metadata (if available)
multigrid.metadata = PatchDataIO.ReadBinMetadata(br);
// Read coloring
multigrid.coloring = (GridData.Coloring)br.ReadByte();
// Read categories (without values)
int gridCount = br.ReadInt32();
if (gridCount > 0)
{
multigrid.categories = new GridCategory[gridCount];
for (int i = 0; i < gridCount; i++)
{
multigrid.categories[i] = new GridCategory(br.ReadString(), null, Color.white);
}
}
}
private static void ReadValues(StreamReader sr, MultiGridData multigrid, string filename)
{
int categoriesCount = multigrid.categories == null? 0 : multigrid.categories.Length;
if (categoriesCount == 0)
{
return;
}
List <float>[] data = new List <float> [categoriesCount];
for (int i = 0; i < categoriesCount; i++)
{
data[i] = new List <float>();
}
string line;
string[] cells;
float value;
var cultureInfo = CultureInfo.InvariantCulture;
// Read each data row at a time with value
while ((line = sr.ReadLine()) != null)
{
cells = line.Split(',');
for (int i = 0; i < categoriesCount; i++)
{
value = float.Parse(cells[i], cultureInfo);
data[i].Add(value);
var g = multigrid.categories[i].grid;
g.minValue = Mathf.Min(g.minValue, value);
g.maxValue = Mathf.Max(g.maxValue, value);
}
}
for (int i = 0; i < categoriesCount; i++)
{
multigrid.categories[i].grid.values = data[i].ToArray();
}
}
//
// Public Methods
//
public void ShowProperties(DataLayer layer, Site site)
{
activeLayer = layer;
activeSite = site;
if (activeLayer == null)
{
return;
}
properties.name.Init(activeLayer.Name);
properties.group.Init(activeLayer.Group);
properties.color.Init(activeLayer.Color);
layerNameInput.text = properties.name;
UpdateGroupsDropdown(properties.group);
colorButton.image.color = properties.color;
if (layer.IsTemp)
{
layerNameInput.readOnly = true;
groupDropdown.interactable = false;
addGroupButton.interactable = false;
}
else
{
layerNameInput.readOnly = false;
groupDropdown.interactable = true;
addGroupButton.interactable = true;
}
properties.site.Init();
properties.year.Init();
properties.units.Init();
properties.categories.Init();
properties.coloring.Init();
properties.metadata.Init();
#if !UNITY_WEBGL
if (activeSite == null || layer.IsTemp)
#endif
{
sitePanel.SetActive(false);
metadataPanel.SetActive(false);
}
#if !UNITY_WEBGL
else
{
properties.site.Init(activeSite.Name);
sitePanel.SetActive(true);
metadataPanel.SetActive(true);
UpdateSitesDropdown(activeSite);
// Gather data from all the layer's patches
List <int> years = new List <int>();
List <string> units = new List <string>();
List <DataType> types = new List <DataType>();
List <GridData.Coloring> styles = new List <GridData.Coloring>();
List <Category> categories = null;
bool differentCategories = false;
List <MetadataPair> metadata = null;
bool differentMetadata = false;
foreach (var level in layer.levels)
{
foreach (var layerSite in level.layerSites)
{
if (layerSite.Site == activeSite)
{
foreach (var record in layerSite.records)
{
var siteRecord = record.Value;
if (!years.Contains(siteRecord.Year))
{
years.Add(siteRecord.Year);
}
foreach (var patch in siteRecord.patches)
{
var filename = patch.Filename;
string type = Patch.GetFileNameType(filename);
if (type.Equals(GridDataIO.FileSufix))
{
GridData data = patch.Data as GridData;
if (!data.IsLoaded())
{
data = QuickReadGridPatch(filename);
}
if (!units.Contains(data.units))
{
units.Add(data.units);
}
var dataType = data.IsCategorized ? DataType.Categorised : DataType.Continuous;
if (!types.Contains(dataType))
{
types.Add(dataType);
}
if (!styles.Contains(data.coloring))
{
styles.Add(data.coloring);
}
if (data.IsCategorized && !differentCategories)
{
if (categories != null)
{
if (!categories.SequenceEqual(data.categories))
{
categories.Clear();
differentCategories = true;
}
}
else if (data.categories != null)
{
categories = new List <Category>(data.categories);
}
}
if (!differentMetadata)
{
if (metadata != null)
{
if (!metadata.SequenceEqual(data.metadata))
{
metadata.Clear();
differentMetadata = true;
}
}
else if (data.metadata != null)
{
metadata = new List <MetadataPair>(data.metadata);
}
}
}
else if (type.Equals(MultiGridDataIO.FileSufix))
{
MultiGridData data = patch.Data as MultiGridData;
if (!data.IsLoaded())
{
data = QuickReadMultiGridPatch(filename);
}
if (!units.Contains(null))
{
units.Add(null);
}
if (!types.Contains(DataType.Categorised))
{
types.Add(DataType.Categorised);
}
if (!styles.Contains(data.coloring))
{
styles.Add(data.coloring);
}
}
else if (type.Equals(GraphDataIO.FileSufix))
{
types.Add(DataType.Graph);
}
else
{
types.Add(DataType.Unknown);
}
}
}
break;
}
}
}
// Update Year
if (years.Count != 1)
{
yearInput.interactable = false;
yearInput.text = "";
}
else
{
properties.year.Init(years[0]);
yearInput.interactable = true;
yearInput.text = properties.year.Value.ToString();
}
// Update Units
if (units.Count != 1)
{
unitsInput.interactable = false;
unitsInput.text = "";
}
else
{
properties.units.Init(units[0]);
unitsInput.interactable = true;
unitsInput.text = properties.units;
}
// Update Type
if (types.Count != 1)
{
typeInput.text = "";
categoriesButton.interactable = false;
}
else
{
typeInput.text = types[0].ToString();
properties.categories.Init(categories?.ToArray());
categoriesButton.interactable = !differentCategories && categories != null && categories.Count > 0;
}
// Update Style
if (styles.Count != 1)
{
styleButton.interactable =
styleDropdown.interactable = false;
styleDropdown.transform.GetChild(0).gameObject.SetActive(true);
styleDropdown.captionText.text = "";
}
else
{
properties.coloring.Init(styles[0]);
styleDropdown.transform.GetChild(0).gameObject.SetActive(false);
styleDropdown.interactable = true;
styleButton.interactable = properties.coloring == GridData.Coloring.Custom;
styleDropdown.onValueChanged.RemoveListener(OnStyleDropdownChanged);
styleDropdown.value = (int)properties.coloring.Value;
styleDropdown.onValueChanged.AddListener(OnStyleDropdownChanged);
}
// Update Metadata
if (differentMetadata)
{
noMetadataMessage.SetActive(false);
multipleMetadataMessage.SetActive(true);
addMetadataButton.interactable = false;
ClearMetadata();
}
else if (metadata == null || metadata.Count == 0)
{
noMetadataMessage.SetActive(true);
multipleMetadataMessage.SetActive(false);
bool validMetadata = types.Count == 1 && (types[0] == DataType.Continuous || types[0] == DataType.Categorised);
addMetadataButton.interactable = validMetadata;
ClearMetadata();
}
else
{
properties.metadata.Init(metadata);
noMetadataMessage.SetActive(false);
multipleMetadataMessage.SetActive(false);
addMetadataButton.interactable = true;
UpdateMetadataList(properties.metadata);
}
}
#endif
}
public MultiGridPatch(DataLayer dataLayer, int level, int year, MultiGridData multigrid, string filename)
: base(dataLayer, level, year, filename)
{
this.multigrid = multigrid;
multigrid.patch = this;
}
private static void ParseCsv(ParseTaskData data)
{
GridDataIO.Parameter parameter = null;
bool[] found = new bool[GridDataIO.Parameters.Length];
string line = null;
string[] cells = null;
bool skipLineRead = false;
GridData grid = new GridData();
MultiGridData multigrid = null;
while (true)
{
if (!skipLineRead)
{
line = data.sr.ReadLine();
}
else
{
skipLineRead = false;
}
if (line == null)
{
break;
}
cells = line.Split(',');
parameter = GridDataIO.CheckParameter(cells[0], cells[1], GridDataIO.Parameters, out bool hasData);
if (parameter == null)
{
#if UNITY_EDITOR
Debug.LogWarning("File " + data.filename + " has unrecognized header parameter " + cells[0] + ". Should it go to the metadata?");
#endif
if (grid.metadata != null)
{
grid.metadata.Add(cells[0], cells[1]);
}
continue;
}
#if UNITY_EDITOR
if (found[(int)parameter.id])
{
Debug.LogWarning("File " + data.filename + " has duplicate metadata entry: " + parameter.label);
}
#endif
found[(int)parameter.id] = true;
switch (parameter.id)
{
case GridDataIO.ParamId.Metadata:
if (hasData)
{
grid.metadata = PatchDataIO.ReadCsvMetadata(data.sr, GridDataIO.CsvTokens, ref line);
skipLineRead = line != null;
}
break;
//case GridDataIO.ParamId.NameToValue:
// if (hasData)
// {
// nameToValues = GridDataIO.ReadCsvNameToValues(sr, CsvTokens, ref line);
// skipLineRead = line != null;
// }
// break;
case GridDataIO.ParamId.Categories:
if (hasData)
{
grid.categories = GridDataIO.ReadCsvCategories(data.sr, data.filename, GridDataIO.CsvTokens, ref line);
skipLineRead = line != null;
}
break;
case GridDataIO.ParamId.Coloring:
case GridDataIO.ParamId.Colouring:
try
{
grid.coloring = (GridData.Coloring)Enum.Parse(typeof(GridData.Coloring), cells[1], true);
}
catch (Exception)
{
grid.coloring = GridData.Coloring.Single;
}
break;
case GridDataIO.ParamId.West:
grid.west = double.Parse(cells[1], CultureInfo.InvariantCulture);
break;
case GridDataIO.ParamId.North:
grid.north = double.Parse(cells[1], CultureInfo.InvariantCulture);
if (grid.north > GeoCalculator.MaxLatitude)
{
Debug.LogWarning("File " + data.filename + " has north above " + GeoCalculator.MaxLatitude + ": " + grid.north);
}
break;
case GridDataIO.ParamId.East:
grid.east = double.Parse(cells[1], CultureInfo.InvariantCulture);
break;
case GridDataIO.ParamId.South:
grid.south = double.Parse(cells[1], CultureInfo.InvariantCulture);
if (grid.south < GeoCalculator.MinLatitude)
{
Debug.LogWarning("File " + data.filename + " has south below " + GeoCalculator.MinLatitude + ": " + grid.south);
}
break;
case GridDataIO.ParamId.CountX:
grid.countX = int.Parse(cells[1]);
break;
case GridDataIO.ParamId.CountY:
grid.countY = int.Parse(cells[1]);
break;
case GridDataIO.ParamId.Units:
grid.units = cells[1];
break;
case GridDataIO.ParamId.Values:
multigrid = new MultiGridData(grid);
ReadValues(data.sr, multigrid, data.filename);
break;
default:
#if UNITY_EDITOR
Debug.Log("File " + data.filename + " will ignore row: " + line);
#endif
skipLineRead = false;
break;
}
}
#if UNITY_EDITOR
foreach (var p in GridDataIO.Parameters)
{
if (p.isRequired && !found[(int)p.id])
{
Debug.LogError("Didn't find " + p.label + " in " + data.filename);
}
}
#endif
data.patch = multigrid;
}
public static IEnumerator LoadBin(this MultiGridData mulyigrid, string filename, PatchDataLoadedCallback <MultiGridData> callback)
{
yield return(FileRequest.GetBinary(filename, (br) => callback(ParseBin(br, filename, mulyigrid))));
}
private void OnMultiGridChange(MultiGridData grid)
{
OnCategoriesChange(grid.categories);
}
