public static IField2d <float> GetWaterinessMap(WaterTableField wtf, IField2d <float> rainfall, float waterPortability = 5f, float waterinessAttenuation = 20f)
{
// Generate "water flow" map using the rainfall map and the water table map, characterizing
// how much water is in an area based on upstream. Note that, in the simplistic case of
// identical universal rainfall, this is just a scalar on depth; this whole shindig is
// intended to support variable rainfall, as characterized by the rainfall map.
Field2d <float> waterFlow = new Field2d <float>(rainfall);
float maxValue = float.MinValue;
foreach (TreeNode <Point2d> waterway in wtf.Waterways)
{
List <TreeNode <Point2d> > flattenedReversedRiverTree = new List <TreeNode <Point2d> >(waterway);
flattenedReversedRiverTree.Reverse();
foreach (var node in flattenedReversedRiverTree)
{
if (node.parent != null)
{
Point2d cur = node.value;
Point2d par = node.parent.value;
waterFlow[par.y, par.x] += waterFlow[cur.y, cur.x];
}
maxValue = Math.Max(maxValue, waterFlow[node.value.y, node.value.x]);
}
}
IField2d <float> waterinessUnblurred = new FunctionField <float>(waterFlow.Width, waterFlow.Height,
(x, y) => 1f / (1f + (float)Math.Pow(Math.E, -waterinessAttenuation * waterFlow[y, x] / maxValue)));
return(new BlurredField(waterinessUnblurred, waterPortability));
}
private static string BuildFunctionField(FunctionField field)
{
var builder = new StringBuilder();
if (field is CustomFunction)
{
var c = (CustomFunction)field;
builder.Append(c.FunctionName.ToUpper())
.Append($"({BuildSqlValueList(c.Parameters)}) ");
return(builder.ToString());
}
if (field is AverageField)
{
builder.Append("AVG");
}
if (field is CountField)
{
builder.Append("COUNT");
}
if (field is LeftField)
{
builder.Append("LEFT");
}
if (field is RightField)
{
builder.Append("RIGHT");
}
if (field is MaxField)
{
builder.Append("MAX");
}
if (field is MinField)
{
builder.Append("MIN");
}
if (field is SumField)
{
builder.Append("SUM");
}
builder.Append("(")
.Append(field.Type == FunctionType.All ? string.Empty : "DISTINCT ")
.Append(HBDCommon.GetSqlName(field.Name))
.Append(") ")
.Append(BuildAlias(field));
return(builder.ToString());
}
/// <summary>
/// //选择字段时，显示它们的具体信息
/// </summary>
/// <param name="dgv"></param>
/// <param name="e"></param>
private void SetDgvSource(ref DataGridView dgv, DataGridViewCellEventArgs e)
{
dgvDetail.DataSource = null;
dgvTableContent.DataSource = null;
if (e.RowIndex < 0 || e.ColumnIndex < 0)
{
return;
}
String name = dgv.Rows[e.RowIndex].Cells[FuncFieldText.NAME].Value.ToString();
String dataType = dgv.Rows[e.RowIndex].Cells[FuncFieldText.DATATYPE].Value.ToString();
String dataTypeName = dgv.Rows[e.RowIndex].Cells[FuncFieldText.DATATYPENAME].Value.ToString();
String defaultValue = dgv.Rows[e.RowIndex].Cells[FuncFieldText.DEFAULTVALUE].Value.ToString();
selectedField = new FunctionField(name, dataType, dataTypeName, defaultValue);
if (String.IsNullOrEmpty(selectedField.Name))
{
MessageBox.Show("点击选择参数");
return;
}
if (dataType == SAPDataType.STRUCTURE.ToString() || dataType == SAPDataType.TABLE.ToString())
{
if (!function.FunctionMeta.StructureDetail.Keys.Contains(dataTypeName))
{
return;
}
else
{
DataTable dt = function.FunctionMeta.StructureDetail[dataTypeName];
dgvDetail.DataSource = dt;
dgvDetail.AutoResizeColumns();
if (function.TableValueList.Keys.Contains(selectedField.Name))
{
DataTable dtResult = function.TableValueList[selectedField.Name];
if (dtResult != null)
{
dgvTableContent.DataSource = dtResult;
dgvTableContent.AutoResizeColumns();
}
}
}
}
}
public static Tables.View LoadView(Type type)
{
if (_viewCache == null)
{
_viewCache = new Dictionary <Type, Tables.View>();
}
if (!_viewCache.ContainsKey(type))
{
object[] attrs = type.GetCustomAttributes(typeof(Attributes.View), true).ToArray();
if (attrs != null)
{
Tables.View view = new Tables.View();
foreach (Attributes.View attr in attrs)
{
var tableLeft = attr.ModelLeft != null?LoadTable(attr.ModelLeft) : null;
var tableRight = attr.ModelRight != null?LoadTable(attr.ModelRight) : null;
if (tableLeft != null && tableRight != null)
{
var fieldLeft = (attr.ModelProperyLeft is string) ? tableLeft.GetFieldByPropertyName((string)attr.ModelProperyLeft) : null;
var fieldRight = (attr.ModelProperyRight is string) ? tableRight?.GetFieldByPropertyName((string)attr.ModelProperyRight) ?? null : null;
if (fieldLeft != null || fieldRight != null)
{
var joinType = JoinType.Cross;
switch (attr.Connect)
{
case Attributes.ViewConnect.Check: joinType = JoinType.LeftOuter; break;
case Attributes.ViewConnect.CheckExisting: joinType = JoinType.Inner; break;
}
Conditions.Condition cond = null;
if (fieldLeft != null && fieldRight != null)
{
cond = Conditions.Condition.AndField(tableLeft.Name + "." + fieldLeft.Name, tableRight.Name + "." + fieldRight.Name);
}
else if (fieldLeft != null && fieldRight == null)
{
cond = Conditions.Condition.AndValue(tableLeft.Name + "." + fieldLeft.Name, attr.ModelProperyRight);
}
else if (fieldLeft == null && fieldRight != null)
{
cond = Conditions.Condition.AndValue(tableRight.Name + "." + fieldRight.Name, attr.ModelProperyLeft);
}
if (cond != null)
{
view.AddJoin(Join.Create(tableLeft.Name, tableRight.Name, cond, joinType));
}
}
}
foreach (var field in type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance))
{
object[] fieldAttrs = field.GetCustomAttributes(typeof(Attributes.ViewField), true);
if (fieldAttrs != null && fieldAttrs.Any())
{
foreach (Attributes.ViewField fieldAttr in fieldAttrs)
{
var table = LoadTable(fieldAttr.ModelType);
if (table != null)
{
string name = !string.IsNullOrEmpty(fieldAttr.ModelProperyName) ? fieldAttr.ModelProperyName : field.Name;
if (_fieldsCache.ContainsKey(type) && _fieldsCache[type].Any(x => x.Name == name))
{
view.AddField(table.Name, table.Type, _fieldsCache[type].FirstOrDefault(x => x.Name == name));
}
else
{
var tableField = table.GetFieldByPropertyName(fieldAttr.ModelProperyName);
if (tableField != null)
{
string tableFieldName = null;
if (fieldAttr is Attributes.AggregateField)
{
tableFieldName = tableField.Name;
var functionField = FunctionField.CreateFunctionAggregateField(field, (Attributes.AggregateField)fieldAttr, tableField);
if (functionField != null)
{
tableFieldName += functionField.Name;
tableField = functionField;
}
view.AddField(table.Name, table.Type, tableField, tableField.Name);
}
else
{
var loadedFields = LoadField(tableField.Property);
foreach (var loadField in loadedFields)
{
loadField.Property = field;
view.AddField(table.Name, table.Type, loadField);
}
}
}
}
}
}
}
}
}
if (view.Tables != null)
{
_fieldsCache.Add(type, view.Tables.SelectMany(x => x.Fields.Values).ToArray());
_viewCache.Add(type, view);
}
else
{
return(null);
}
}
else
{
throw new Exceptions.TableAttributeException("No view attributes in type");
}
}
return(_viewCache[type]);
}
private static void LoadFromDisk(IEnumerable<Function> list, nHydrateModel model, string rootFolder, Microsoft.VisualStudio.Modeling.Store store)
{
var folder = Path.Combine(rootFolder, FOLDER_FC);
if (!Directory.Exists(folder)) return;
#region Load other parameter/field information
var fList = Directory.GetFiles(folder, "*.configuration.xml");
foreach (var f in fList)
{
var document = new XmlDocument();
try
{
document.Load(f);
}
catch (Exception ex)
{
//Do Nothing
MessageBox.Show("The file '" + f + "' is not valid and could not be loaded!", "Load Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var fi = new FileInfo(f);
var name = fi.Name.Substring(0, fi.Name.Length - ".configuration.xml".Length).ToLower();
var itemID = XmlHelper.GetAttributeValue(document.DocumentElement, "id", Guid.Empty);
var item = list.FirstOrDefault(x => x.Id == itemID);
if (item == null)
{
item = new Function(model.Partition, new PropertyAssignment[] { new PropertyAssignment(ElementFactory.IdPropertyAssignment, XmlHelper.GetAttributeValue(document.DocumentElement, "id", Guid.NewGuid())) });
model.Functions.Add(item);
}
System.Windows.Forms.Application.DoEvents();
item.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(FieldParameter_PropertyChanged);
item.Name = XmlHelper.GetAttributeValue(document.DocumentElement, "name", item.Name);
item.PrecedenceOrder = XmlHelper.GetAttributeValue(document.DocumentElement, "precedenceorder", item.PrecedenceOrder);
item.IsGenerated = XmlHelper.GetAttributeValue(document.DocumentElement, "isgenerated", item.IsGenerated);
item.CodeFacade = XmlHelper.GetAttributeValue(document.DocumentElement, "codefacade", item.CodeFacade);
item.Schema = XmlHelper.GetAttributeValue(document.DocumentElement, "schema", item.Schema);
item.IsTable = XmlHelper.GetAttributeValue(document.DocumentElement, "istable", item.IsTable);
item.ReturnVariable = XmlHelper.GetAttributeValue(document.DocumentElement, "returnvariable", item.ReturnVariable);
item.Summary = XmlHelper.GetNodeValue(document.DocumentElement, "summary", item.Summary);
item.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(FieldParameter_PropertyChanged);
//Fields
var fieldsNodes = document.DocumentElement.SelectSingleNode("//fieldset");
if (fieldsNodes != null)
{
var nameList = new List<string>();
foreach (XmlNode n in fieldsNodes.ChildNodes)
{
var subItemID = XmlHelper.GetAttributeValue(n, "id", Guid.Empty);
var field = item.Fields.FirstOrDefault(x => x.Id == subItemID);
if (field == null)
{
field = new FunctionField(item.Partition, new PropertyAssignment[] { new PropertyAssignment(ElementFactory.IdPropertyAssignment, XmlHelper.GetAttributeValue(n, "id", Guid.NewGuid())) });
item.Fields.Add(field);
}
field.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(FieldParameter_PropertyChanged);
field.Name = XmlHelper.GetAttributeValue(n, "name", field.Name);
field.CodeFacade = XmlHelper.GetAttributeValue(n, "codefacade", field.CodeFacade);
nameList.Add(field.Name.ToLower());
field.Nullable = XmlHelper.GetAttributeValue(n, "nullable", field.Nullable);
var dtv = XmlHelper.GetAttributeValue(n, "datatype", field.DataType.ToString());
DataTypeConstants dt;
if (Enum.TryParse<DataTypeConstants>(dtv, true, out dt))
field.DataType = dt;
field.Default = XmlHelper.GetAttributeValue(n, "default", field.Default);
field.IsGenerated = XmlHelper.GetAttributeValue(n, "isgenerated", field.IsGenerated);
field.Length = XmlHelper.GetAttributeValue(n, "length", field.Length);
field.Scale = XmlHelper.GetAttributeValue(n, "scale", field.Scale);
field.Summary = XmlHelper.GetNodeValue(n, "summary", field.Summary);
field.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(FieldParameter_PropertyChanged);
}
if (item.Fields.Remove(x => !nameList.Contains(x.Name.ToLower())) > 0)
item.nHydrateModel.IsDirty = true;
}
//Parameters
var parametersNodes = document.DocumentElement.SelectSingleNode("//parameterset");
if (parametersNodes != null)
{
var nameList = new List<string>();
foreach (XmlNode n in parametersNodes.ChildNodes)
{
var subItemID = XmlHelper.GetAttributeValue(n, "id", Guid.Empty);
var parameter = item.Parameters.FirstOrDefault(x => x.Id == subItemID);
if (parameter == null)
{
parameter = new FunctionParameter(item.Partition, new PropertyAssignment[] { new PropertyAssignment(ElementFactory.IdPropertyAssignment, XmlHelper.GetAttributeValue(n, "id", Guid.NewGuid())) });
item.Parameters.Add(parameter);
}
parameter.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(FieldParameter_PropertyChanged);
parameter.CodeFacade = XmlHelper.GetAttributeValue(n, "codefacade", parameter.CodeFacade);
parameter.Name = XmlHelper.GetAttributeValue(n, "name", parameter.Name);
nameList.Add(parameter.Name.ToLower());
parameter.Nullable = XmlHelper.GetAttributeValue(n, "nullable", parameter.Nullable);
var dtv = XmlHelper.GetAttributeValue(n, "datatype", parameter.DataType.ToString());
DataTypeConstants dt;
if (Enum.TryParse<DataTypeConstants>(dtv, true, out dt))
parameter.DataType = dt;
parameter.Default = XmlHelper.GetAttributeValue(n, "default", parameter.Default);
parameter.IsGenerated = XmlHelper.GetAttributeValue(n, "isgenerated", parameter.IsGenerated);
parameter.Length = XmlHelper.GetAttributeValue(n, "length", parameter.Length);
parameter.Scale = XmlHelper.GetAttributeValue(n, "scale", parameter.Scale);
parameter.Summary = XmlHelper.GetNodeValue(n, "summary", parameter.Summary);
parameter.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(FieldParameter_PropertyChanged);
}
if (item.Parameters.Remove(x => !nameList.Contains(x.Name.ToLower())) > 0)
item.nHydrateModel.IsDirty = true;
}
LoadModules(folder, item);
}
#endregion
#region Load SQL
fList = Directory.GetFiles(folder, "*.sql");
foreach (var f in fList)
{
var fi = new FileInfo(f);
if (fi.Name.ToLower().EndsWith(".sql"))
{
var name = fi.Name.Substring(0, fi.Name.Length - 4).ToLower();
var item = list.FirstOrDefault(x => x.Name.ToLower() == name);
if (item != null)
{
item.SQL = File.ReadAllText(f);
System.Windows.Forms.Application.DoEvents();
}
}
}
#endregion
}