public override void AppendFeatures(HostnameSplitterResult parsedHostname, GeonamesCityEntity cityEntity, Features features)
{
if (parsedHostname == null ||
parsedHostname.DomainInfo?.RegistrableDomain == null ||
parsedHostname.SubdomainParts == null ||
parsedHostname.SubdomainParts.Count == 0 ||
cityEntity == null)
{
return;
}
var domain = parsedHostname.DomainInfo.RegistrableDomain;
Dictionary <PatternRule, PatternMiningCoordinates> rulesToCoordinates;
if (!this.hostnamePatternRules.TryGetValue(domain, out rulesToCoordinates))
{
return;
}
var subdomainParts = parsedHostname.SubdomainParts;
if (subdomainParts == null || subdomainParts.Count == 0)
{
return;
}
var ruleAtoms = this.miner.CreateRuleAtoms(subdomainParts);
if (ruleAtoms == null || ruleAtoms.Count == 0)
{
return;
}
var rules = this.miner.GeneratePossibleRules(ruleAtoms);
if (rules == null || rules.Count == 0)
{
return;
}
foreach (var rule in rules)
{
PatternMiningCoordinates coordinates;
if (rulesToCoordinates.TryGetValue(rule, out coordinates))
{
var distance = DistanceHelper.Distance(cityEntity.Latitude, cityEntity.Longitude, coordinates.Latitude, coordinates.Longitude, DistanceUnit.Kilometer);
// TODO: Make this configurable
// TODO: Distance should vary depending on geohash length?
if (distance <= 100)
{
features[CityFeatureType.HostnamePatternMatch] = true;
}
}
}
}
public async Task <IEnumerable <Location> > GetBusinessLocationsWithinRadius(double latitude, double longitude, double radius, string searchText)
{
var root = await _businessDbContext.Locations.Include(y => y.AdditionalLocationImages).ToListAsync();
IList <Location> list = new List <Location>();
foreach (var item in root)
{
if (DistanceHelper.Distance(latitude, longitude, item.Geolocation.Latitude, item.Geolocation.Longitude, 'K') <= radius)
{
list.Add(item);
}
}
return(list);
}
public string GetLocationCity(double longitude, double latitude)
{
Dictionary <string, double> lst = new Dictionary <string, double>();
List <TbCityEntity> dataList = _cityRepository.ListAll()?.ToList();
foreach (var item in dataList)
{
double dis = DistanceHelper.Distance(latitude, longitude, item.Latitude, item.Longitude);
lst.Add(item.CityName, dis);
}
var result2 = from pair in lst orderby pair.Value select pair.Key;
return(result2.FirstOrDefault());
}
private ClassificationResult PickBestByPattern(string hostname, List <ClassificationResult> results)
{
var splitResults = HostnameSplitter.Split(hostname);
if (splitResults == null || splitResults.DomainInfo?.RegistrableDomain == null || splitResults.SubdomainParts == null || splitResults.SubdomainParts.Count == 0)
{
return(null);
}
var domain = splitResults.DomainInfo.RegistrableDomain;
Dictionary <PatternRule, PatternMiningCoordinates> rulesToCoordinates;
if (!this.reducedRules.TryGetValue(domain, out rulesToCoordinates))
{
return(null);
}
var subdomainParts = splitResults.SubdomainParts;
if (subdomainParts == null || subdomainParts.Count == 0)
{
return(null);
}
var ruleAtoms = this.miner.CreateRuleAtoms(subdomainParts);
if (ruleAtoms == null || ruleAtoms.Count == 0)
{
return(null);
}
var rules = this.miner.GeneratePossibleRules(ruleAtoms);
if (rules == null || rules.Count == 0)
{
return(null);
}
var filteredRulesToCoordinates = new Dictionary <PatternRule, PatternMiningCoordinates>();
foreach (var rule in rules)
{
PatternMiningCoordinates coordinates;
if (rulesToCoordinates.TryGetValue(rule, out coordinates))
{
filteredRulesToCoordinates[rule] = coordinates;
}
}
ClassificationResult closestResult = null;
double smallestDistanceKm = int.MaxValue;
PatternRule bestRule = null;
foreach (var result in results)
{
if (result.City != null)
{
foreach (var entry in filteredRulesToCoordinates)
{
var rule = entry.Key;
var coordinates = entry.Value;
var distance = DistanceHelper.Distance(result.City.Latitude, result.City.Longitude, coordinates.Latitude, coordinates.Longitude, DistanceUnit.Kilometer);
if (distance < smallestDistanceKm)
{
closestResult = result;
smallestDistanceKm = distance;
bestRule = rule;
}
}
}
}
if (closestResult != null && smallestDistanceKm <= this.distanceThresholdKm)
{
return(closestResult);
}
return(null);
}
public async void CalculateDistance(double lat, double lon)
{
this.Distance = DistanceHelper.Distance(lat, lon, Latitude, Longitude, 'K');
}
public async void CalculateDistance(Geocoordinate coordinates)
{
this.Distance = DistanceHelper.Distance(coordinates.Latitude, coordinates.Longitude, Latitude, Longitude, 'K');
}
public double DetermineDistance(CoordWithOcc item1, CoordWithOcc item2)
{
return(DistanceHelper.Distance(item1.Coord.Latitude, item1.Coord.Longitude, item2.Coord.Latitude, item2.Coord.Longitude, DistanceUnit.Kilometer));
}
public double DetermineDistance(PatternMiningCoordinates item1, PatternMiningCoordinates item2)
{
return(DistanceHelper.Distance(item1.Latitude, item1.Longitude, item2.Latitude, item2.Longitude));
}
public static List <Rectangle> Compute(Size imageSize, LineSegment2D[] lines)
{
const double scaleStep = 0.5;
const double minScale = 0.1;
const double ratio = 1.5;
var allLines = lines.Select(RotateLineSegment2D).ToArray();
var left = default(LineSegment2D);
var right = default(LineSegment2D);
var leftPoint = new Point(int.MinValue, 0);
var rightPoint = new Point(int.MaxValue, 0);
var viewPoint = imageSize.Width / 2;
foreach (var line in allLines)
{
var start = FindStartingPoint(line, imageSize.Width, imageSize.Height, false);
if (start.X >= leftPoint.X && start.X <= viewPoint)
{
left = line;
leftPoint = start;
}
else if (start.X <= rightPoint.X && start.X > viewPoint)
{
right = line;
rightPoint = start;
}
}
var maxY = Math.Min(FindStartingPoint(left, imageSize.Width, imageSize.Height, true).Y,
FindStartingPoint(right, imageSize.Width, imageSize.Height, true).Y);
leftPoint = FindStartingPoint(left, imageSize.Width, maxY, false);
rightPoint = FindStartingPoint(right, imageSize.Width, maxY, false);
var intersection = Intersection(left, right);
var windowSize = rightPoint.X - leftPoint.X;
var windowMiddlePoint = new Point(leftPoint.X + windowSize / 2, leftPoint.Y);
var windowDirection =
new PointF(-(left.Direction.X + right.Direction.X * left.Direction.Y / right.Direction.Y) / 2,
-left.Direction.Y);
var middleDistance =
(float)Math.Sqrt(windowDirection.X * windowDirection.X + windowDirection.Y * windowDirection.Y);
windowDirection = new PointF(windowDirection.X / middleDistance, windowDirection.Y / middleDistance);
//calculate step count
var stepCount = 0;
var temp = minScale;
do
{
temp = temp / scaleStep;
++stepCount;
} while (temp < 1);
var coefficient = DistanceHelper.Distance(windowMiddlePoint, intersection);
var scale = 1.0;
var windows = new List <Rectangle>();
for (var i = 0; i < stepCount; ++i)
{
var windowWidth = windowSize * scale;
var windowHeight = windowWidth / ratio;
var length = (1.0 - scale) * coefficient;
var position = new Point((int)(windowMiddlePoint.X + windowDirection.X * length),
(int)(windowMiddlePoint.Y + windowDirection.Y * length));
var windowLeft = position.X - windowWidth / 2;
var windowDown = position.Y - windowHeight;
windows.Add(new Rectangle((int)windowLeft, (int)windowDown, (int)windowWidth, (int)windowHeight));
scale *= scaleStep;
}
return(windows);
}
private ClassificationResult FilterByPatterns(string hostname, ClassificationResult result)
{
if (result == null)
{
return(null);
}
var splitResults = HostnameSplitter.Split(hostname);
if (splitResults == null || splitResults.DomainInfo?.RegistrableDomain == null || splitResults.SubdomainParts == null || splitResults.SubdomainParts.Count == 0)
{
return(null);
}
var domain = splitResults.DomainInfo.RegistrableDomain;
Dictionary <PatternRule, PatternMiningCoordinates> rulesToCoordinates;
if (!this.reducedRules.TryGetValue(domain, out rulesToCoordinates))
{
return(null);
}
var subdomainParts = splitResults.SubdomainParts;
if (subdomainParts == null || subdomainParts.Count == 0)
{
return(null);
}
var ruleAtoms = this.miner.CreateRuleAtoms(subdomainParts);
if (ruleAtoms == null || ruleAtoms.Count == 0)
{
return(null);
}
var rules = this.miner.GeneratePossibleRules(ruleAtoms);
if (rules == null || rules.Count == 0)
{
return(null);
}
var filteredRulesToCoordinates = new Dictionary <PatternRule, PatternMiningCoordinates>();
foreach (var rule in rules)
{
PatternMiningCoordinates coordinates;
if (rulesToCoordinates.TryGetValue(rule, out coordinates))
{
var distance = DistanceHelper.Distance(result.City.Latitude, result.City.Longitude, coordinates.Latitude, coordinates.Longitude, DistanceUnit.Kilometer);
if (distance > this.distanceThresholdKm)
{
return(null);
}
}
}
return(result);
}
