private static void generateLocations() { var prefectureList = new PrefectureList(); var municipalityNameTransfer = new MunicipalityNameTransfer(); var postalCodeFileReader = new PostalCodeFileReader(municipalityNameTransfer, new TownAreaNameTransfer()); foreach (var postalCode in postalCodeFileReader.ReadFile(postalCodePath)) { prefectureList.Add(postalCode); } var addressFileReader = new AddressFileReader(municipalityNameTransfer); foreach (var address in Directory.GetFiles(addressFolder).SelectMany(x => addressFileReader.ReadFile(Path.Combine(addressFolder, x)))) { prefectureList.Add(address); } var locationMatcher = new LocationMatcher(); IReadOnlyList <LocationMatch> foundLocations = locationMatcher.FindLocations(prefectureList); var locationCalculator = new LocationCalculator(); IReadOnlyList <Location> locations = locationCalculator.Calculate(foundLocations); File.WriteAllText(locationPath, JsonSerializer.PrettyPrint(JsonSerializer.Serialize(locations))); Console.WriteLine("output Locations.json"); }
/// <summary> /// Első eset: a két távolság által jelzett kör messze van egymástól: /// Megoldás: mindkettőt arányosan növeljük /// </summary> protected bool CheckFarDistances(TagDisplay tag1, TagDisplay tag2) { if (LocationCalculator.Distance(tag1.Origo, tag2.Origo) > tag1.Distance + tag2.Distance) { double deviance = LocationCalculator.Distance(tag1.Origo, tag2.Origo) - (tag1.Distance + tag2.Distance); deviance += BIAS; // Az eltérés torzítása, így biztosan lesz metszéspont double max = tag1.Distance + tag2.Distance; double rate1 = tag1.Distance / max; double rate2 = tag2.Distance / max; tag1.ChangeDistance(tag1.Distance + deviance * rate1); tag2.ChangeDistance(tag2.Distance + deviance * rate2); //TEST double dist = LocationCalculator.Distance(tag1.Origo, tag2.Origo) - (tag1.Distance + tag2.Distance); if (dist > 0.0) { dist = 0; /* throw new Exception("Calculation error: distance must be 0.0"); */ } //TEST return(true); } else { return(false); } }
protected internal static async Task <string> GetNameAsync(LocationCalculator calc, Stream stream, uint nameRVA) { var fileOffset = calc.RVAToOffset(nameRVA); stream.Seek(fileOffset.ToInt64(), SeekOrigin.Begin); var result = await stream.ReadStringAsync().ConfigureAwait(false); return(result); }
public void AlignByKey() { var viewModel = new AlignmentViewModel(this, CreateAlignment()); var bounds = new LocationCalculator().CalculateBounds(Handle, KeyGrabOffset); using (var grabber = UIManager.GetKeyGrabber(viewModel)) { grabber.SetBounds(bounds); grabber.Display(); } }
public void ItShouldReturnLatIfMeterIsZero() { //Arrange double inputLat = 71.639566053691; double inputMeter = 0; //Act double result = LocationCalculator.MoveY(inputLat, inputMeter); //Assert Assert.True(result == inputLat); }
public void ItShouldReturnNewLatitude() { //Arrange double oldLat = 71.639566053691; double meters = -7500d; //Act double newLat = LocationCalculator.CalcLatMeters(oldLat, meters); //Assert Assert.True(newLat == 71.572192407382033); }
public void ItShouldReturnNewLongitude() { //Arrange double oldLon = -51.1902823595313; double meters = 10000; double oldLat = 71.639566053691; //Act double newLat = LocationCalculator.CalcLonMeters(oldLon, meters, oldLat); //Assert Assert.True(newLat == -50.905097207707151); }
private static async Task <ushort[]> BuildFunctionOrdinalsAsync(LocationCalculator calc, Stream stream, IMAGE_EXPORT_DIRECTORY directory) { var offset = calc.RVAToOffset(directory.AddressOfNameOrdinals).ToInt64(); stream.Seek(offset, SeekOrigin.Begin); var results = new ushort[directory.NumberOfNames]; for (var i = 0; i < directory.NumberOfNames; i++) { results[i] = await stream.ReadUInt16Async().ConfigureAwait(false); } return(results); }
private Point getClosestPoint(Point P, List <Point> IntersectionPoints) { int mini = 0; Point intersectionPoint; double mindist = LocationCalculator.Distance(P, IntersectionPoints[0]); double dist; for (int i = 1; i < IntersectionPoints.Count; i++) { intersectionPoint = IntersectionPoints[i]; dist = LocationCalculator.Distance(P, intersectionPoint); if (dist < mindist) { mini = i; mindist = dist; } } return(IntersectionPoints[mini]); }
/// <summary> /// Második eset: az egyik kör a másikon belül helyezkedik el: /// Megoldás: a nagyobb kört arányosan csökkentjük, a kisebb kört pedig arányosan növeljük /// </summary> protected bool CheckInclude(TagDisplay tag1, TagDisplay tag2) { TagDisplay bigger, smaller; if (tag1.Includes(tag2)) { bigger = tag1; smaller = tag2; } else if (tag2.Includes(tag1)) { bigger = tag2; smaller = tag1; } else { return(false); } double deviance = bigger.Distance - (LocationCalculator.Distance(bigger.Origo, smaller.Origo) + smaller.Distance); deviance += BIAS; // Az eltérés torzítása, így biztosan lesz metszéspont double max = bigger.Distance + smaller.Distance; double brate = bigger.Distance / max; double srate = smaller.Distance / max; bigger.ChangeDistance(bigger.Distance - deviance * brate); smaller.ChangeDistance(smaller.Distance + deviance * srate); //TEST double dist = bigger.Distance - (LocationCalculator.Distance(bigger.Origo, smaller.Origo) + smaller.Distance); if (dist > 0.0) { dist = 0; /* throw new Exception("Calculation error: distance must be 0.0"); */ } //TEST return(true); }
public static GeoPoint Move(GeoPoint startingPosition, IEnumerable <SantaMovement> movements) { GeoPoint currentPosition = startingPosition; GeoPoint newPosition = new GeoPoint(0, 0); foreach (SantaMovement move in movements) { double xMeters = 0d; double yMeters = 0d; switch (move.Direction) { case "left": xMeters -= move.Value; break; case "right": xMeters += move.Value; break; case "up": yMeters += move.Value; break; case "down": yMeters -= move.Value; break; default: throw new Exception("direction not supported"); } newPosition.lon = LocationCalculator.MoveX(currentPosition.lon, xMeters, currentPosition.lat); newPosition.lat = LocationCalculator.MoveY(currentPosition.lat, yMeters); currentPosition = new GeoPoint(newPosition.lat, newPosition.lon); } return(currentPosition); }
public LocationResult CalculateLocation(List <TagDisplay> NearbyDistances, LocationResult LastLocation) { List <TagDisplay> Distances = NearbyDistances.ToList <TagDisplay>(); // Ha azt akarjuk hogy az eredeti körök ne változzanak, akkor ezt shallow copyzni kell //Distances.RemoveAll(tag => tag.AverageRSSI == 0.0); if (Distances.Count == 0) { return(new LocationResult(new Point(-1, -1), Precision.NoTag)); } if (Distances.Count == 1) { return(new LocationResult(Distances[0].Origo, Precision.OneTag, Distances[0].Distance)); // 1 vagy semennyi kör esetén nem tudunk pozíciót meghatározni } if (Distances.Count == 2) // 2 kör esetén a metszet két pontja közti felezőpont kell { ForceAllIntersections(Distances); Intersection points = Intersection.CalculateIntersection(Distances[0].Origo, Distances[0].Distance, Distances[1].Origo, Distances[1].Distance); return(new LocationResult(LocationCalculator.Midpoint(points.Points[0], points.Points[1]), Precision.TwoTag, LocationCalculator.Distance(points.Points[0], points.Points[1]) / 2)); } return(CalculateCommonPoint(Distances, LastLocation)); }
private static async Task <string> BuildNameAsync(LocationCalculator calc, Stream stream, IMAGE_EXPORT_DIRECTORY directory) { var builder = new StringBuilder(256); var offset = calc.RVAToOffset(directory.Name).ToInt64(); stream.Seek(offset, SeekOrigin.Begin); while (true) { int value = await stream.ReadByteAsync().ConfigureAwait(false); if (value <= 0) { break; } var c = (char)value; builder.Append(c); } return(builder.ToString()); }
public IntersectDistance(Point P1, Point P2) { this.P1 = P1; this.P2 = P2; this.Distance = LocationCalculator.Distance(P1, P2); }
private double getDistance(Point p1, Point p2, Point p3) { return(LocationCalculator.Distance(p1, p2) + LocationCalculator.Distance(p2, p3) + LocationCalculator.Distance(p1, p3)); }
public void TearDown() { _calc = null; _image.Dispose(); }
public void SetUp() { _image = PortableExecutableImage.FromStream(TestingUtils.GetFileFromResources("nativetest.x64.dll")); _calc = _image.GetCalculator(); }
/// <summary> /// Ez működik általános esetre, amikor nincs pontos metszéspont /// /// A legközelebbi 3 metszéspont átlagpontját adjuk vissza /// Válasszuk ki a metszéspontok távolságai közül a legrövidebb hármat /// Elméletileg a 3 távolság 6 metszéspontja lényegében 3 pont, amit keresünk, ezek átlaga kell /// </summary> public override Point CalculateCommonPoint(List <Intersection> intersections) { List <IntersectDistance> idistances = new List <IntersectDistance>(); // A metszéspontok távolságai IntersectDistance idist; for (int i = 0; i < intersections.Count; i++) { for (int j = 0; j < intersections.Count; j++) { if (i != j) { // Egy metszet két metszéspontjának távolságát nem is vesszük figyelembe idist = new IntersectDistance(intersections[i].Points[0], intersections[j].Points[1]); if (!idistances.Contains(idist)) { idistances.Add(idist); } idist = new IntersectDistance(intersections[i].Points[0], intersections[j].Points[0]); if (!idistances.Contains(idist)) { idistances.Add(idist); } idist = new IntersectDistance(intersections[i].Points[1], intersections[j].Points[1]); if (!idistances.Contains(idist)) { idistances.Add(idist); } } } } //---------------------új megoldás:-------------------- // Az összes metszéspontot ebben a listában tároljuk List <Point> intersectPoints = new List <Point>(); //Ebben a listában tároljuk el a k legközelebbi metszéspontokat List <Point> closestPoints = new List <Point>(); IntersectDistance firstDistance = getMinimumDistance(idistances); closestPoints.Add(firstDistance.P1); closestPoints.Add(firstDistance.P2); foreach (Intersection i in intersections) { foreach (Point p in i.Points) { if (!p.Equals(firstDistance.P1) && !p.Equals(firstDistance.P2)) { intersectPoints.Add(p); } } } Point candidate1 = getClosestPoint(firstDistance.P1, intersectPoints); Point candidate2 = getClosestPoint(firstDistance.P2, intersectPoints); closestPoints.Add(getThirdPoint(candidate1, candidate2, firstDistance)); return(LocationCalculator.PointAverage(closestPoints)); }