public Rule(Symbolizer symbolizer, int?minZoom = null, int?maxZoom = null, FeatureFilter filter = null)
{
Symbolizer = symbolizer;
MinZoom = minZoom;
MaxZoom = maxZoom;
Filter = filter;
}
public async Task <ActionResult> ListFeatures(FeatureParameters parameters)
{
ValidateFeatureParameters(parameters, FeatureParametersValidator.NoValidation);
var filter = new FeatureFilter()
{
FilterMessage = parameters.FilterMessage,
CarLine = parameters.CarLine,
ModelYear = parameters.ModelYear,
Gateway = parameters.Gateway,
Action = FeatureAction.Features
};
filter.InitialiseFromJson(parameters);
var results = await FeatureViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.Features.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public FeatureSelectionAnalysis(String _name, SpaceModel _space, FeatureFilter _filter, Int32 _FSl)
{
name = _name;
//space = _space.Clone();
inputTerms = _space.terms.Clone();
filter = _filter.CloneViaXML();
filter.limit = _FSl;
}
private static async Task <IEnumerable <FdpFeature> > ListFeatures(IDataContext context, TakeRateDocument forDocument)
{
if (forDocument.UnderlyingOxoDocument is EmptyOxoDocument)
{
return(Enumerable.Empty <FdpFeature>());
}
return(await context.Vehicle.ListFeatures(FeatureFilter.FromOxoDocumentId(forDocument.UnderlyingOxoDocument.Id)));
}
public async Task <ActionResult> FeaturePage(FeatureParameters parameters)
{
var filter = new FeatureFilter()
{
PageIndex = PageIndex,
PageSize = PageSize
};
return(View(await FeatureViewModel.GetModel(DataContext, filter)));
}
private static FeatureViewModel GetFullAndPartialViewModel(IDataContext context,
FeatureFilter filter)
{
var model = new FeatureViewModel(SharedModelBase.GetBaseModel(context))
{
Configuration = context.ConfigurationSettings,
};
HydrateModelWithCommonProperties(model, context);
return(model);
}
/// <summary>
/// Specify a feature check to the endpoint(s).
/// </summary>
/// <typeparam name="TBuilder"><see cref="IEndpointConventionBuilder"/></typeparam>
/// <param name="builder">The endopoint convention builder.</param>
/// <param name="names">A coma separated list of features names to be evaluated.</param>
/// <param name="productName">The product name to be checked with the <paramref name="featureName"/> parameter.</param>
/// <returns>The original convention builder to be chained.</returns>
public static TBuilder RequireFeature <TBuilder>(this TBuilder builder, string names, string productName = null) where TBuilder : IEndpointConventionBuilder
{
builder.Add(endpointbuilder =>
{
var metadata = new FeatureFilter(names, productName);
endpointbuilder.Metadata
.Add(metadata);
});
return(builder);
}
public async Task <ActionResult> ContextMenu(FeatureParameters parameters)
{
ValidateFeatureParameters(parameters, FeatureParametersValidator.FeatureIdentifier);
var filter = FeatureFilter.FromParameters(parameters);
filter.Action = FeatureAction.Feature;
var derivativeView = await FeatureViewModel.GetModel(DataContext, filter);
return(PartialView("_ContextMenu", derivativeView));
}
public void render3d(Project project, SceneManager sceneMgr)
{
SharpMap.Map myMap = new SharpMap.Map();
foreach (BuildLayer layer in project.getLayers())
{
Source source = layer.getSource();
BoundingBox envelope = new BoundingBox(-1000.0, -1000.0, 1000.0, 1000.0);//TODO
FeatureDataSet ds = new FeatureDataSet();
source.DataSource.Open();
source.DataSource.ExecuteIntersectionQuery(envelope, ds);
source.DataSource.Close();
FeatureDataTable features = (FeatureDataTable)ds.Tables[0];
//El codigo del PFC
//**********************************************************************************************************
//Show map
//Filters
FilterGraph graph = project.getFilterGraph(source.getName());
if (graph != null)
{
graph.Successors();
FilterEnv env = new FilterEnv(sceneMgr, source.getName());
FeatureList list = Feature.DataTableToList(features);
if (graph.getFilter(1) is FeatureFilter)
{
FeatureFilter filter = (FeatureFilter)graph.getFilter(1);
FeatureList l = filter.process(list, env);
}
else if (graph.getFilter(1) is FragmentFilter)
{
FragmentFilter filter = (FragmentFilter)graph.getFilter(1);
FragmentList l = filter.process(list, env);
}
}
//**********************************************************************************************************
}
}
public FeatureFilter GetFilter()
{
var filter = new FeatureFilter();
foreach (MapzenFeatureCollection collection in Enum.GetValues(typeof(MapzenFeatureCollection)))
{
if ((FeatureCollection & collection) != 0)
{
filter.CollectionNameSet.Add(collection.ToString().ToLower());
}
}
if (Matchers == null || Matchers.Count == 0)
{
return(filter);
}
else
{
IFeatureMatcher[] predicates = Matchers.Select(m => m.GetFeatureMatcher()).ToArray();
switch (Combiner)
{
case MatcherCombiner.None:
filter.Matcher = predicates.First();
break;
case MatcherCombiner.AllOf:
filter.Matcher = FeatureMatcher.AllOf(predicates);
break;
case MatcherCombiner.AnyOf:
filter.Matcher = FeatureMatcher.AnyOf(predicates);
break;
case MatcherCombiner.NoneOf:
filter.Matcher = FeatureMatcher.NoneOf(predicates);
break;
default:
break;
}
}
return(filter);
}
public FdpFeature FdpFeatureGet(FeatureFilter filter)
{
FdpFeature retVal = new EmptyFdpFeature();
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpFeatureId", filter.FeatureId.GetValueOrDefault(), DbType.Int32);
retVal = conn.Query <FdpFeature>("dbo.Fdp_Feature_Get", para, commandType: CommandType.StoredProcedure).FirstOrDefault();
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
public IEnumerable <FdpFeature> FeatureGetManyByDocumentId(FeatureFilter filter)
{
var retVal = Enumerable.Empty <FdpFeature>();
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@DocumentId", filter.DocumentId.Value, DbType.Int32);
retVal = conn.Query <FdpFeature>("Fdp_ProgrammeFeature_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
public static async Task <FeatureViewModel> GetModel(IDataContext context, FeatureFilter featureFilter)
{
FeatureViewModel model = null;
if (featureFilter.Action == FeatureAction.Delete || featureFilter.Action == FeatureAction.Feature)
{
model = await GetFullAndPartialViewModelForFeature(context, featureFilter);
}
else if (featureFilter.Action == FeatureAction.Features)
{
model = await GetFullAndPartialViewModelForFeatures(context, featureFilter);
}
else
{
model = GetFullAndPartialViewModel(context, featureFilter);
}
if (featureFilter.Action != FeatureAction.NotSet)
{
model.IdentifierPrefix = Enum.GetName(featureFilter.Action.GetType(), featureFilter.Action);
}
return(model);
}
private void ExtractFeature(FeatureFilter featureFilter, double[] centerPoint)
{
using (var fileStream = File.OpenRead(FeatureConfig.CityOSMData.GetPathInStreamingAssets()))
{
var membersFilter = featureFilter.RelationMembers;
var relationMembersTags = membersFilter.Select(rm => rm.Tags).ToArray();
var source = new PBFOsmStreamSource(fileStream);
IEnumerable <OsmGeo> filtered = from osmGeo in source
where osmGeo.Type == OsmGeoType.Node ||
osmGeo.Type == OsmGeoType.Way ||
(osmGeo.Type == OsmGeoType.Relation && osmGeo.Tags != null && DoTagsMatch(osmGeo.Tags, featureFilter.Tags))
select osmGeo;
List <Node> nodes = new List <Node>();
List <Way> ways = new List <Way>();
List <OsmSharp.Relation> relations = new List <OsmSharp.Relation>();
foreach (var geo in filtered)
{
switch (geo.Type)
{
case OsmGeoType.Node:
nodes.Add(geo as Node);
break;
case OsmGeoType.Way:
if (geo.Tags != null && DoTagsMatch(geo.Tags, relationMembersTags))
{
ways.Add(geo as Way);
}
break;
case OsmGeoType.Relation:
if (geo.Tags != null && (DoTagsMatch(geo.Tags, featureFilter.Tags) || DoTagsMatch(geo.Tags, relationMembersTags)))
{
relations.Add(geo as OsmSharp.Relation);
}
break;
}
}
filtered = null;
UnityEngine.Debug.Log("Nodes: " + nodes.Count);
UnityEngine.Debug.Log("Ways: " + ways.Count);
UnityEngine.Debug.Log("Relations: " + relations.Count);
var featureRelations = new List <Relation>();
var featureLines = new List <Line>();
// Extract feature relations
for (int r = 0; r < relations.Count; r++)
{
var relationGeo = relations[r];
var relationMembers = GetRelationMembers(relationGeo);
var relation = new Relation
{
Id = relationGeo.Id.Value,
Type = Type.Relation,
Tags = featureFilter.Tags.AllOfTags.Select(tso => new Tag()
{
Key = tso.Key, Value = tso.Value
}).ToArray(),
Members = relationMembers
};
featureRelations.Add(relation);
ExtractLines(relationMembers);
}
// Extract relation members
RelationMember[] GetRelationMembers(OsmSharp.Relation relationGeo)
{
var members = new List <RelationMember>();
for (int mf = 0; mf < membersFilter.Length; mf++)
{
var memberFilter = membersFilter[mf];
var osmMembers = relationGeo.Members
.Where(m => GetGeoType(m.Type) == memberFilter.Type && m.Role == memberFilter.Role).ToArray();
for (int m = 0; m < osmMembers.Length; m++)
{
var osmMember = osmMembers[m];
OsmGeo osmMemberGeo = null;
switch (osmMember.Type)
{
case OsmGeoType.Node:
osmMemberGeo = nodes.FirstOrDefault(geo => geo.Id.Value == osmMember.Id);
break;
case OsmGeoType.Way:
osmMemberGeo = ways.FirstOrDefault(geo => geo.Id.Value == osmMember.Id);
break;
case OsmGeoType.Relation:
osmMemberGeo = relations.FirstOrDefault(geo => geo.Id.Value == osmMember.Id);
break;
}
if (osmMemberGeo == null)
{
UnityEngine.Debug.Log("Relation Member tags don't match: " + osmMember.Id);
continue;
}
if (DoTagsMatch(osmMemberGeo.Tags, memberFilter.Tags))
{
var member = new RelationMember
{
Id = osmMember.Id,
Type = GetGeoType(osmMember.Type),
Role = osmMember.Role
};
members.Add(member);
}
}
}
return(members.ToArray());
}
// Extract feature lines and points
void ExtractLines(RelationMember[] members)
{
// Get node ids
Dictionary <long, long[]> memberNodes = new Dictionary <long, long[]>();
List <long> nodeIds = new List <long>();
for (int m = 0; m < members.Length; m++)
{
var member = members[m];
if (member.Type == Type.Line)
{
var way = ways.FirstOrDefault(w => w.Id == member.Id);
memberNodes.Add(way.Id.Value, way.Nodes);
nodeIds.AddRange(way.Nodes);
}
}
// Get nodes
List <Node> memberNodesGeo = new List <Node>();
for (int ni = 0; ni < nodeIds.Count; ni++)
{
memberNodesGeo.Add(nodes.FirstOrDefault(n => n.Id == nodeIds[ni]));
}
// Extract points
for (int m = 0; m < members.Length; m++)
{
var member = members[m];
var points = new List <Point>();
var memberNodeIds = memberNodes.FirstOrDefault(mn => mn.Key == member.Id).Value;
for (int ni = 0; ni < memberNodeIds.Length; ni++)
{
var node = memberNodesGeo.FirstOrDefault(n => n.Id.Value == memberNodeIds[ni]);
points.Add(ToPoint(node, centerPoint));
}
var line = new Line
{
Id = member.Id,
Points = points.ToArray()
};
featureLines.Add(line);
}
}
var feature = new Feature
{
Relations = featureRelations.ToArray(),
Lines = featureLines.ToArray()
};
var bytes = MessagePackSerializer.Serialize(feature);
var featureFileName = FeatureConfig.CityName.Value + nameSeparator + featureFilter.Name + FeatureConfig.GeoFormat;
var featureDataPath = Path.Combine(FeatureConfig.FeaturesDataPath.GetPathInStreamingAssets(), featureFileName);
File.WriteAllBytes(featureDataPath, bytes);
}
}
/// <summary>
/// 根据条件获取3GX数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public XmlDocument GetFeatures(FeatureFilter filter)
{
return(ObjectCreate <string> .CreateIGGGX("GGGXBusinesscs").GetFeatures(filter));
}
public PagedResults <FdpFeature> FdpFeatureGetMany(FeatureFilter filter)
{
PagedResults <FdpFeature> retVal = null;
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = DynamicParameters.FromCDSId(CurrentCDSID);
var totalRecords = 0;
var totalDisplayRecords = 0;
if (!string.IsNullOrEmpty(filter.CarLine))
{
para.Add("@CarLine", filter.CarLine, DbType.String);
}
if (!string.IsNullOrEmpty(filter.ModelYear))
{
para.Add("@ModelYear", filter.ModelYear, DbType.String);
}
if (!string.IsNullOrEmpty(filter.Gateway))
{
para.Add("@Gateway", filter.Gateway, DbType.String);
}
para.Add("@DocumentId", filter.DocumentId, DbType.Int32);
if (filter.PageIndex.HasValue)
{
para.Add("@PageIndex", filter.PageIndex.Value, DbType.Int32);
}
if (filter.PageSize.HasValue)
{
para.Add("@PageSize", filter.PageSize.HasValue ? filter.PageSize.Value : 10, DbType.Int32);
}
if (filter.SortIndex.HasValue)
{
para.Add("@SortIndex", filter.SortIndex.Value, DbType.Int32);
}
if (filter.SortDirection != SortDirection.NotSet)
{
var direction = filter.SortDirection == SortDirection.Descending ? "DESC" : "ASC";
para.Add("@SortDirection", direction, DbType.String);
}
if (filter.ProgrammeId.HasValue)
{
para.Add("@ProgrammeId", filter.ProgrammeId, DbType.Int32);
}
if (!string.IsNullOrEmpty(filter.Gateway))
{
para.Add("@Gateway", filter.Gateway, DbType.String);
}
if (!string.IsNullOrEmpty(filter.FilterMessage))
{
para.Add("@Filter", filter.FilterMessage, DbType.String);
}
para.Add("@TotalPages", dbType: DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalRecords", dbType: DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalDisplayRecords", dbType: DbType.Int32, direction: ParameterDirection.Output);
var results = conn.Query <FdpFeature>("dbo.Fdp_FeatureMapping_GetMany", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
totalRecords = para.Get <int>("@TotalRecords");
totalDisplayRecords = para.Get <int>("@TotalDisplayRecords");
}
retVal = new PagedResults <FdpFeature>
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
TotalRecords = totalRecords,
TotalDisplayRecords = totalDisplayRecords,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : totalRecords
};
var currentPage = new List <FdpFeature>();
foreach (var result in results)
{
currentPage.Add(result);
}
retVal.CurrentPage = currentPage;
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
/// <summary>
/// 根据条件获取3GX数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public XmlDocument GetFeatures(FeatureFilter filter)
{
string sqlWhere = string.Empty;
StringBuilder strSql = new StringBuilder();
strSql.Append("SELECT DISTINCT BO.*,OBJECTTYPE.BOT,OBJECTTYPE.FT FROM BO,OBJECTTYPE");
if (!string.IsNullOrEmpty(filter.BBox))
{
strSql.Append(",v_Geometry ");
}
if (filter.Filter != null)
{
strSql.Append(" ,PROPERTY PROPERTY ");
strSql.Append(" WHERE BO.BOTID = OBJECTTYPE.BOTID ");
strSql.Append(" AND PROPERTY.BOID = BO.BOID ");
strSql.Append(string.Format(" AND OBJECTTYPE.FT='{0}' ", filter.FT));
strSql.Append(" AND BO.BOTID=OBJECTTYPE.BOTID ");
}
else
{
strSql.Append(string.Format(" WHERE OBJECTTYPE.FT='{0}' ", filter.FT));
strSql.Append(" AND BO.BOTID=OBJECTTYPE.BOTID ");
}
//对象名称
if (filter.BOs != null && filter.BOs.Count > 0)
{
string bos = string.Empty;
for (int i = 0; i < filter.BOs.Count; i++)
{
if (i == filter.BOs.Count - 1)
{
bos += "'" + filter.BOs[i].Trim() + "'";
}
else
{
bos += "'" + filter.BOs[i].Trim() + "',";
}
}
strSql.Append(string.Format(" AND BO.NAME in {0} ", bos));
}
//空间范围和crs 未启用坐标范围
if (!string.IsNullOrEmpty(filter.BBox))
{
strSql.Append(" AND v_Geometry.BOID=BO.BOID ");
strSql.Append(string.Format(" AND ( v_Geometry.GEOMETRY.STWithin(GEOGRAPHY::STGeomFromText('{0}', 4326))=1 or ", filter.BBox));
strSql.Append(string.Format(" v_Geometry.GEOMETRY.STIntersects(GEOGRAPHY::STGeomFromText('{0}', 4326))=1 ) ", filter.BBox));
}
//属性
if (filter.Filter != null)
{
JObject jObj = JObject.Parse(filter.Filter.ToString());
string bot = SqlServerDBHelper.ExecuteQueryText <string>(string.Format("SELECT BOT FROM OBJECTTYPE WHERE FT='{0}'", filter.FT)).FirstOrDefault();
strSql.Append(" AND " + "( " + MongoJsonToSql.JsonToSql(jObj.ToString(), bot).ToString() + " )");
}
DataTable dt = SqlServerDBHelper.GetDataTable(strSql.ToString());
List <GeoFeature> ftList = new List <GeoFeature>();
foreach (DataRow row in dt.Rows)
{
GeoFeature ft = new GeoFeature();
ft.BOID = row["Boid"].ToString();
ft.BOT = row["BOT"].ToString();
ft.FT = row["FT"].ToString();
ft.NAME = row["Name"].ToString();
ft.AliasNameList = Comm.GetAliasNameByBoid(ft.BOID);
ft.PropertyList = Comm.GetPropertyByBoid(ft.BOID);
ft.GeometryList = Comm.GetGeometryByBoid(ft.BOID);
ftList.Add(ft);
}
return(GGGXParse.ConvertFT.FeatureToGGGX(ftList));
}
/// <summary>
/// Gets default configuration
/// </summary>
/// <returns></returns>
public static PlanesMethodSettings GetDefaultSettings()
{
PlanesMethodSettings output = new PlanesMethodSettings();
output.entityMethod.instructions.Add(DocumentRenderInstruction.GetDescriptionInstruction());
output.entityMethod.instructions.Add(DocumentRenderInstruction.GetTitleInstruction());
output.entityMethod.instructions.Add(DocumentRenderInstruction.GetBodyTextInstruction());
// output.entityMethod.blenderOptions = DocumentBlenderFunctionOptions.binaryAggregation | DocumentBlenderFunctionOptions.pageLevel;
output.entityMethod.filterFunctionName = ""; // nameof(DocumentEntropyFunction);
output.entityMethod.filterLimit = 5;
output.corpusMethod.stemmer = nameof(EnglishStemmer);
output.corpusMethod.tokenizer = nameof(TokenizerBasic);
output.corpusMethod.transliterationRuleSetId = "";
#region PREPARE Weighting model
var weightModel = new FeatureWeightModel();
weightModel.LocalFunction = new Weighting.Local.TermFrequencyFunction();
var globalFactor = new FeatureWeightFactor();
globalFactor.Settings.functionName = nameof(IDFElement);
weightModel.GlobalFactors.Add(globalFactor);
output.corpusMethod.WeightModel = weightModel;
#endregion
var featureFilter = new FeatureFilter();
featureFilter.limit = 8000;
//featureFilter.
//featureFilter.functionSettings = new GlobalFunctionSettings();
//featureFilter.functionSettings.functionName = nameof(CollectionTDPElement);
//featureFilter.functionSettings.weight = 1.0;
//featureFilter.functionSettings.flags.Add(Weighting.Metrics.TDPFactor.chi.ToString());
output.corpusMethod.filter = featureFilter;
/*
* output.vectorMethod.constructor = new Feature.Settings.FeatureVectorConstructorSettings();
* dimensionSpecification dimSpec = new dimensionSpecification();
* dimSpec.functionName = nameof(CosineSimilarityFunction);
* dimSpec.type = FeatureVectorDimensionType.similarityFunction;
* output.vectorMethod.constructor.labelDimensions.Add(dimSpec);
*/
//output.vectorMethod.constructor = new Feature.Settings.FeatureVectorConstructorSettings();
//dimensionSpecification dimSpec = new dimensionSpecification();
////dimSpec.functionName = nameof(CosineSimilarityFunction);
//dimSpec.type = FeatureVectorDimensionType.directTermWeight;
//output.vectorMethod.constructor.featureDimensions.Add(dimSpec);
output.featureMethod.classifierSettings.type = Classifiers.ClassifierType.multiClassSVM;
output.featureMethod.classifierSettings.lossFunctionForTraining = Accord.MachineLearning.VectorMachines.Learning.Loss.L2;
/*
* output.featureMethod.classifierSettings.type = Classifiers.ClassifierType.kNearestNeighbors;
* output.featureMethod.classifierSettings.lossFunctionForTraining = Accord.MachineLearning.VectorMachines.Learning.Loss.L2;
* output.featureMethod.classifierSettings.kNN_k = 4;
*/
return(output);
}
private static async Task <FeatureViewModel> GetFullAndPartialViewModelForFeature(IDataContext context,
FeatureFilter filter)
{
var model = new FeatureViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings
};
var feature = await context.Vehicle.GetFdpFeature(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = feature.ProgrammeId,
Gateway = feature.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
if (!(feature is EmptyFdpFeature))
{
feature.Programme = model.Programmes.FirstOrDefault(p => p.Id == feature.ProgrammeId.GetValueOrDefault());
}
model.Feature = feature;
return(model);
}
public async Task <IEnumerable <FdpFeature> > ListFeatures(FeatureFilter filter)
{
return(await Task.FromResult(_featureDataStore.FeatureGetManyByDocumentId(filter)));
}
private static async Task <FeatureViewModel> GetFullAndPartialViewModelForFeatures(IDataContext context,
FeatureFilter filter)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new FeatureViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Features = await context.Vehicle.ListFdpFeatures(filter);
model.TotalPages = model.Features.TotalPages;
model.TotalRecords = model.Features.TotalRecords;
model.TotalDisplayRecords = model.Features.TotalDisplayRecords;
foreach (var feature in model.Features.CurrentPage)
{
feature.Programme = model.Programmes.FirstOrDefault(p => p.Id == feature.ProgrammeId.GetValueOrDefault());
}
return(model);
}
public async Task <FdpFeature> GetFdpFeature(FeatureFilter filter)
{
return(await Task.FromResult(_featureDataStore.FdpFeatureGet(filter)));
}
public async Task <PagedResults <FdpFeature> > ListFdpFeatures(FeatureFilter filter)
{
return(await Task.FromResult(_featureDataStore.FdpFeatureGetMany(filter)));
}
private void ExtractFeature(FeatureFilter featureFilter, double[] centerPoint)
{
using (var fileStream = File.OpenRead(FeatureConfig.CityOSMData.GetPathInStreamingAssets()))
{
var source = new PBFOsmStreamSource(fileStream);
var filtered = from osmGeo in source
where osmGeo.Type == OsmGeoType.Node ||
osmGeo.Type == OsmGeoType.Way ||
(osmGeo.Type == OsmGeoType.Relation && osmGeo.Tags != null && DoTagsMatch(osmGeo.Tags, featureFilter.Tags))
select osmGeo;
var complete = filtered.ToComplete();
var relationsCompleted = complete.Where(x => x.Type == OsmGeoType.Relation).ToArray();
var relations = new Relation[relationsCompleted.Length];
var lines = new List <Line>();
UnityEngine.Debug.Log(relationsCompleted.Length);
for (int r = 0; r < relations.Length; r++)
{
// Get RelationMembers
foreach (OsmGeo osmgeo in filtered)
{
var osmRelation = osmgeo as OsmSharp.Relation;
if (osmRelation == null || osmRelation.Id != relationsCompleted[r].Id)
{
continue;
}
var relationMembers = GetMembers(filtered.ToArray(), osmRelation, featureFilter.RelationMembers);
UnityEngine.Debug.Log(relationMembers.Length);
var relation = new Relation
{
Id = osmRelation.Id.Value,
Type = Type.Relation,
Tags = featureFilter.Tags.AllOfTags.Select(tso => new Tag()
{
Key = tso.Key, Value = tso.Value
}).ToArray(),
Members = relationMembers
};
relations[r] = relation;
}
var relationMemberIds = relations[r].Members.Select(rm => rm.Id);
// Get Ids
Dictionary <long, long[]> memberNodes = new Dictionary <long, long[]>();
List <long> nodeIds = new List <long>();
foreach (OsmGeo osmgeo in filtered)
{
var way = osmgeo as Way;
if (way == null || !relationMemberIds.Contains(way.Id.Value))
{
continue;
}
memberNodes.Add(way.Id.Value, way.Nodes);
nodeIds.AddRange(way.Nodes);
}
// Get Nodes
List <Node> nodes = new List <Node>();
foreach (OsmGeo osmGeo in filtered)
{
var node = osmGeo as Node;
if (node == null || !nodeIds.Contains(node.Id.Value))
{
continue;
}
nodes.Add(node);
}
// Add Relation Member Points
for (int m = 0; m < relations[r].Members.Length; m++)
{
var member = relations[r].Members[m];
var points = new List <Point>();
var memberNodeIds = memberNodes.FirstOrDefault(mn => mn.Key == member.Id).Value;
for (int ni = 0; ni < memberNodeIds.Length; ni++)
{
var node = nodes.FirstOrDefault(n => n.Id.Value == memberNodeIds[ni]);
points.Add(ToPoint(node, centerPoint));
}
var line = new Line
{
Id = member.Id,
Points = points.ToArray()
};
lines.Add(line);
}
}
var feature = new Feature
{
Relations = relations,
Lines = lines.ToArray()
};
var bytes = MessagePackSerializer.Serialize(feature);
var featureFileName = FeatureConfig.CityName.Value + nameSeparator + featureFilter.Name + FeatureConfig.GeoFormat;
var featureDataPath = Path.Combine(FeatureConfig.FeaturesDataPath.GetPathInStreamingAssets(), featureFileName);
File.WriteAllBytes(featureDataPath, bytes);
}
}
private static async Task <ImportViewModel> GetFullAndPartialViewModelForException(IDataContext context,
ImportQueueFilter filter)
{
var model = new ImportViewModel(GetBaseModel(context))
{
PageIndex = filter.PageIndex ?? 1,
PageSize = filter.PageSize ?? int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentException = await context.Import.GetException(filter)
};
var programmeFilter = new ProgrammeFilter(model.CurrentException.ProgrammeId)
{
DocumentId = model.CurrentException.DocumentId
};
var featureFilter = new FeatureFilter {
ProgrammeId = model.CurrentException.ProgrammeId, DocumentId = model.CurrentException.DocumentId
};
model.Programme = context.Vehicle.GetProgramme(programmeFilter);
programmeFilter.VehicleId = model.Programme.VehicleId;
model.Gateway = model.CurrentException.Gateway;
model.AvailableDocuments = context.Vehicle.ListPublishedDocuments(programmeFilter);
model.AvailableEngines = context.Vehicle.ListEngines(programmeFilter);
model.AvailableTransmissions = context.Vehicle.ListTransmissions(programmeFilter);
model.AvailableBodies = context.Vehicle.ListBodies(programmeFilter);
model.AvailableSpecialFeatures = await context.TakeRate.ListSpecialFeatures(programmeFilter);
model.AvailableMarkets = await context.Market.ListAvailableMarkets();
model.AvailableFeatures = await context.Vehicle.ListFeatures(featureFilter);
model.AvailableFeatureGroups = context.Vehicle.ListFeatureGroups(programmeFilter);
model.AvailableTrimLevels = context.Vehicle.ListTrimLevels(programmeFilter);
var derivativeFilter = new DerivativeFilter
{
CarLine = model.Programme.VehicleName,
ModelYear = model.Programme.ModelYear,
Gateway = model.Gateway,
ProgrammeId = model.CurrentException.ProgrammeId,
};
model.AvailableDerivatives = context.Vehicle.ListDerivatives(derivativeFilter);
model.AvailableImportDerivatives = await ListImportDerivatives(model.CurrentException.ImportQueueId, context);
model.AvailableImportTrimLevels = await ListImportTrimLevels(model.CurrentException.ImportQueueId, context);
model.AvailableImportFeatures = await ListImportFeatures(model.CurrentException.ImportQueueId, context);
derivativeFilter.Bmc = model.CurrentException.ImportDerivativeCode;
var trimFilter = new TrimMappingFilter
{
CarLine = model.Programme.VehicleName,
ModelYear = model.Programme.ModelYear,
Gateway = model.Gateway,
DocumentId = model.CurrentException is EmptyOxoDocument ? (int?)null : model.CurrentException.DocumentId,
IncludeAllTrim = false
};
model.AvailableTrim = (await context.Vehicle.ListOxoTrim(trimFilter)).CurrentPage;
model.Document = model.AvailableDocuments.FirstOrDefault(d => d.Id == model.CurrentException.DocumentId);
return(model);
}
public static void SetReportDataFields(this classificationReport report, IClassifier classifier, FeatureFilter filter, FeatureWeightModel featureWeight)
{
report.data.Add(nameof(ReportDataFieldEnum.Classifier), classifier.GetSignature(), "Signature of the classification algorithm");
report.data.Add(nameof(ReportDataFieldEnum.FeatureSelection), filter.GetSignature(), "Signature of feature selection filter model");
report.data.Add(nameof(ReportDataFieldEnum.FeatureWeighting), featureWeight.GetSignature(), "Signature of feature weight model");
}
/// <summary>
/// 根据条件获取3GX数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public XmlDocument GetFeatures(FeatureFilter filter)
{
string sqlWhere = string.Empty;
StringBuilder strSql = new StringBuilder();
strSql.Append("SELECT DISTINCT BO.*,OBJECTTYPE.BOT,OBJECTTYPE.FT FROM BO,OBJECTTYPE,Geometry");
if (filter.Filter != null)
{
strSql.Append(" ,PROPERTY PROPERTY ");
strSql.Append(" WHERE BO.BOTID = OBJECTTYPE.BOTID ");
strSql.Append(" AND PROPERTY.BOID = BO.BOID ");
strSql.Append(" AND GEOMETRY.BOID=BO.BOID ");
strSql.Append(string.Format(" AND OBJECTTYPE.FT='{0}' ", filter.FT));
strSql.Append(" AND BO.BOTID=OBJECTTYPE.BOTID AND BO.BOID=GEOMETRY.BOID ");
}
else
{
strSql.Append(string.Format(" WHERE OBJECTTYPE.FT='{0}' ", filter.FT));
strSql.Append(" AND BO.BOTID=OBJECTTYPE.BOTID AND BO.BOID=GEOMETRY.BOID ");
}
//对象名称
if (filter.BOs != null && filter.BOs.Count > 0)
{
string bos = string.Empty;
for (int i = 0; i < filter.BOs.Count; i++)
{
if (i == filter.BOs.Count - 1)
{
bos += "'" + filter.BOs[i].Trim() + "'";
}
else
{
bos += "'" + filter.BOs[i].Trim() + "',";
}
}
strSql.Append(string.Format(" AND BO.NAME in {0} ", bos));
}
//空间范围和crs 未启用坐标范围
if (!string.IsNullOrEmpty(filter.BBox))
{
strSql.Append(" AND SDO_FILTER(GEOMETRY.GEOMETRY, ");
strSql.Append(" SDO_GEOMETRY('" + filter.BBox + "',4326), ");
strSql.Append(" 'QUERYTYPE=WINDOW') = 'TRUE' ");
}
//属性
if (filter.Filter != null)
{
JObject jObj = JObject.Parse(filter.Filter.ToString());
string bot = OracleDBHelper.OracleHelper.ExecuteQueryText <string>(string.Format("SELECT BOT FROM OBJECTTYPE WHERE FT='{0}'", filter.FT)).FirstOrDefault();
strSql.Append(" AND " + "( " + MongoJsonToSql.JsonToSql(jObj.ToString(), bot).ToString() + " )");
}
DataTable dt = OracleDBHelper.OracleHelper.ExecuteQueryText(strSql.ToString()).Tables[0];
List <GeoFeature> ftList = new List <GeoFeature>();
foreach (DataRow row in dt.Rows)
{
GeoFeature ft = new GeoFeature();
ft.BOID = row["Boid"].ToString();
ft.BOT = row["BOT"].ToString();
ft.FT = row["FT"].ToString();
ft.NAME = row["Name"].ToString();
ft.CLASS = GF.Server.Oracle.Comm.GetClassByBoid(ft.BOID);
ft.AliasNameList = Comm.GetAliasNameByBoid(ft.BOID);
ft.PropertyList = Comm.GetPropertyByBoid(ft.BOID);
ft.GeometryList = Comm.GetGeometryByBoid(ft.BOID);
ftList.Add(ft);
}
return(GGGXParse.ConvertFT.FeatureToGGGX(ftList));
}
public FilterStyle(string name)
{
this.name = name;
this.layerStyles = new List <LayerStyle>();
this.filter = new FeatureFilter();
}
