public static double ToMetric(double value, DistanceType inputDistanceType)
{
double _meters = 0D;
switch (inputDistanceType)
{
case DistanceType.MileNautical: _meters = value * GeoConstant.METERSINNMILE;
break;
case DistanceType.Mile: _meters = value * GeoConstant.METERSINMILE;
break;
case DistanceType.Yard: _meters = value * GeoConstant.METERSINYARD;
break;
case DistanceType.Inch: _meters = value * GeoConstant.METERSININCH;
break;
case DistanceType.Foot: _meters = value * GeoConstant.METERSINFOOT;
break;
case DistanceType.Kilometer: _meters = value * 1000D;
break;
case DistanceType.Meter: _meters = value;
break;
case DistanceType.Centimeter: _meters = value / 100D;
break;
case DistanceType.Millimeter: _meters = value / 1000D;
break;
default:
throw new ArgumentException("DistanceType not supported");
}
return _meters;
}
/// Returns -1 if no valid targets
public int FindTarget(Controller targeter, DistanceType distanceType)
{
int targetIndex = -1;
float targetDistance = distanceType == DistanceType.NEAREST ? 0 : float.PositiveInfinity;
for (int i = 0; i < bots.Count; ++i)
{
if (bots[i] != targeter)
{
if (targetIndex == -1)
{
targetIndex = i;
targetDistance = Distance(targeter.transform.position, bots[i].transform.position);
}
else
{
float distance = Distance(targeter.transform.position, bots[i].transform.position);
if (distanceType == DistanceType.NEAREST
? distance <targetDistance : distance> targetDistance)
{
targetIndex = i;
targetDistance = distance;
}
}
}
}
return(targetIndex);
}
/// <summary>
/// Calculate and returns the distance between to points in KM
/// </summary>
/// <param name="lat1">latitude of 1st point</param>
/// <param name="lat2">latitude of 2nd point</param>
/// <param name="long1">longitude of 1st point</param>
/// <param name="long2">longitude of 2nd point</param>
/// <returns>Distance in KM</returns>
public double GetDistance(double lat1, double lat2, double long1, double long2, DistanceType type)
{
double radius = (type == DistanceType.Miles) ? earthRadiusKM : earthRadiusM;
// Declare local variables
double lat1Rad;
double lat2Rad;
double long1Rad;
double long2Rad;
double dlat;
double dlong;
// Convert angles to Radian
lat1Rad = DegreeToRadian(lat1);
lat2Rad = DegreeToRadian(lat2);
long1Rad = DegreeToRadian(long1);
long2Rad = DegreeToRadian(long2);
dlat = lat2Rad - lat1Rad;
dlong = long2Rad - long1Rad;
double a = Math.Pow(Math.Sin(dlat / 2.0), 2.0) +
Math.Cos(lat1Rad) * Math.Cos(lat2Rad) *
Math.Pow(Math.Sin(dlong / 2.0), 2.0);
// Calculate c - great circle distance in Radians
double c = 2.0 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1.0 - a));
// Calculate Distance
distance = radius * c;
return distance;
}
/// <summary>
/// Create a OclBruteForce Matcher using the specific distance type
/// </summary>
/// <param name="distanceType">The distance type</param>
public OclBruteForceMatcher(DistanceType distanceType)
{
if (distanceType == DistanceType.Hamming)
{
if (typeof(T) != typeof(byte))
{
throw new ArgumentException("Hamming distance type requires model descriptor to be Matrix<Byte>");
}
}
if (typeof(T) != typeof(byte) && typeof(T) != typeof(float))
{
throw new NotImplementedException(String.Format("Data type of {0} is not supported", typeof(T).ToString()));
}
switch (distanceType)
{
case (DistanceType.Hamming):
_distanceType = OclMatcherDistanceType.HammingDist;
break;
case (DistanceType.L1):
_distanceType = OclMatcherDistanceType.L1Dist;
break;
case (DistanceType.L2):
_distanceType = OclMatcherDistanceType.L2Dist;
break;
default:
throw new NotImplementedException(String.Format("Distance type of {0} is not implemented in GPU.", distanceType.ToString()));
}
_ptr = OclInvoke.oclBruteForceMatcherCreate(_distanceType);
}
//private GpuMatcherDistanceType _distanceType;
/// <summary>
/// Create a GPUBruteForce Matcher using the specific distance type
/// </summary>
/// <param name="distanceType">The distance type</param>
public GpuBruteForceMatcher(DistanceType distanceType)
{
if (distanceType == DistanceType.Hamming)
{
if (typeof(T) != typeof(byte))
{
throw new ArgumentException("Hamming distance type requires model descriptor to be Matrix<Byte>");
}
}
if (typeof(T) != typeof(byte) && typeof(T) != typeof(float))
{
throw new NotImplementedException(String.Format("Data type of {0} is not supported", typeof(T).ToString()));
}
/*
* switch (distanceType)
* {
* case (DistanceType.Hamming):
* _distanceType = GpuMatcherDistanceType.HammingDist;
* break;
* case (DistanceType.L1):
* _distanceType = GpuMatcherDistanceType.L1Dist;
* break;
* case (DistanceType.L2):
* _distanceType = GpuMatcherDistanceType.L2Dist;
* break;
* default:
* throw new NotImplementedException(String.Format("Distance type of {0} is not implemented in GPU.", distanceType.ToString()));
* }*/
_ptr = GpuInvoke.gpuBruteForceMatcherCreate(distanceType);
}
/// <summary>
/// Given an input feature, a feature space and its associated labels, and a positive integer 'k',
/// Determines the 'k' nearest neighbor label for the input feature. The 'k' value corresponds
/// to the number of nearest neighbors to use in the voting process.
///
/// <remarks>
/// "When I have this grid of data points, and I provide one additional example row, find the 'k' number
/// of rows that are most similar, count up the number of occurrences of each label for each row (1 to 'k'),
/// and choose the label with the highest occurrence."
/// </remarks>
/// <see href="http://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm" />
/// </summary>
/// <param name="distanceType">The type of equation to use when measuring the distance between each data point</param>
/// <param name="input">The matrix row to input; must have the same number of columns as the feature space</param>
/// <param name="featureSpace">The feature space matrix; everything we know</param>
/// <param name="labels">The results for each feature space row; what we call each collection of data points</param>
/// <param name="k">The number of nearest neighbors to include in the voting; the label with the most occurrences in 'k' neighbors wins</param>
/// <returns></returns>
public static string Classify(DistanceType distanceType, Number[] input, Matrix featureSpace, IList<string> labels, int k)
{
if (labels.Count() != featureSpace.Rows)
{
throw new ArgumentException("The number of labels must match the number of rows of data in the feature space", "labels");
}
var distances = CalculateDistances(distanceType, featureSpace, input);
var nearestNeighbors = distances.OrderByDescending(d => d.Value).Take(k);
var votes = new Dictionary<string, int>(k);
foreach (var label in nearestNeighbors.Select(neighbor => labels[neighbor.Key]))
{
if (votes.ContainsKey(label))
{
votes[label]++;
}
else
{
votes.Add(label, 1);
}
}
var nearest = votes.OrderByDescending(v => v.Value).First().Key;
return nearest;
}
/// <summary>
/// Match the Image feature from the observed image to the features from the model image, using brute force matcher
/// </summary>
/// <param name="observedFeatures">The Image feature from the observed image</param>
/// <param name="k">The number of neighbors to find</param>
/// <returns>The matched features</returns>
public MatchedImageFeature[] MatchFeature(ImageFeature <TDescriptor>[] observedFeatures, int k)
{
VectorOfKeyPoint obsKpts;
Matrix <TDescriptor> observedDescriptors;
ImageFeature <TDescriptor> .ConvertToRaw(observedFeatures, out obsKpts, out observedDescriptors);
try
{
DistanceType dt = typeof(TDescriptor) == typeof(Byte) ? DistanceType.Hamming : DistanceType.L2;
using (Matrix <int> indices = new Matrix <int>(observedDescriptors.Rows, k))
using (Matrix <float> dists = new Matrix <float>(observedDescriptors.Rows, k))
using (BruteForceMatcher <TDescriptor> matcher = new BruteForceMatcher <TDescriptor>(dt))
{
matcher.Add(_modelDescriptors);
matcher.KnnMatch(observedDescriptors, indices, dists, k, null);
return(ConvertToMatchedImageFeature(_modelKeyPoints, _modelDescriptors, obsKpts, observedDescriptors, indices, dists, null));
}
}
finally
{
obsKpts.Dispose();
observedDescriptors.Dispose();
}
}
public void SelectNextTargetPositionAndTranslate()
{
distType = (DistanceType)distSample.Dequeue();
Vector2 nextTargetPosition;
do
{
facingWall = Utility.sampleUniform(0, 4);
nextTargetPosition = CalculateTargetPosition(facingWall, distType);
} while(targetPosition == nextTargetPosition);
targetPosition = nextTargetPosition;
gainIndex = gainSample[((int)distType + 1)].Dequeue();
translate = CalculateTranslate(facingWall, gainIndex);
tempTrial += 1;
Debug.Log($"Start {tempTrial} ---------------------");
Debug.Log($"Facing Wall {facingWall}");
Debug.Log($"Opposite Wall {(facingWall + 2) % 4}");
Debug.Log($"Distance from opposite wall {distType}");
Debug.Log($"Applied gain {wallTranslateGain[gainIndex]}");
Debug.Log($"Next target position {targetPosition}");
Debug.Log($"End {tempTrial} ---------------------");
}
/// <summary>
/// Gets the radius of the earth in the specified distance type
/// </summary>
/// <param name="distanceType">The distance unit to return the results in</param>
/// <returns>The earth's radius</returns>
protected static double GetRadius(DistanceType distanceType)
{
double Radius = 0;
switch (distanceType)
{
case DistanceType.KILOMETERS:
{
Radius = EarthRadiusInKilometers;
break;
}
case DistanceType.METERS:
{
Radius = EarthRadiusInKilometers * 1000;
break;
}
case DistanceType.MILES:
{
Radius = EarthRadiusInMiles;
break;
}
}
return(Radius);
}
public Graph(GraphType graphType, DistanceType distanceType)
{
this.graphType = graphType;
this.distanceType = distanceType;
nodes = new List <Node>();
edges = new List <Edge>();
}
private static List <Node> GetPathNodes(Grid grid, Point startPos, Point targetPos,
DistanceType distance = DistanceType.Short, bool ignorePrices = false)
{
var startNode = grid.nodes[startPos.x, startPos.y];
var targetNode = grid.nodes[targetPos.x, targetPos.y];
var openSet = new List <Node>();
var closedSet = new HashSet <Node>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
var currentNode = openSet[0];
for (var i = 1; i < openSet.Count; i++)
{
if (openSet[i].FCost < currentNode.FCost ||
openSet[i].FCost == currentNode.FCost && openSet[i].hCost < currentNode.hCost)
{
currentNode = openSet[i];
}
}
openSet.Remove(currentNode);
closedSet.Add(currentNode);
if (currentNode == targetNode)
{
return(RetracePath(startNode, targetNode));
}
foreach (var neighbour in grid.GetNeighbours(currentNode, distance))
{
if (!neighbour.walkable || closedSet.Contains(neighbour))
{
continue;
}
var neighbourCost = currentNode.gCost + GetDistance(currentNode, neighbour) *
(ignorePrices ? 1 : (int)(10f * neighbour.price));
if (neighbourCost >= neighbour.gCost && openSet.Contains(neighbour))
{
continue;
}
neighbour.gCost = neighbourCost;
neighbour.hCost = GetDistance(neighbour, targetNode);
neighbour.parent = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
}
}
return(null);
}
public static AStar Create(ref byte[,] byteArray, Point start, Point end, bool asBool, DistanceType distanceType = DistanceType.Chebyshev)
{
if (asBool)
return new BoolAStar(ref byteArray, start, end, distanceType);
else
return Create(ref byteArray, start, end, distanceType);
}
/// <summary>
/// Given an input feature, a feature space and its associated labels, and a positive integer 'k',
/// Determines the 'k' nearest neighbor label for the input feature. The 'k' value corresponds
/// to the number of nearest neighbors to use in the voting process.
///
/// <remarks>
/// "When I have this grid of data points, and I provide one additional example row, find the 'k' number
/// of rows that are most similar, count up the number of occurrences of each label for each row (1 to 'k'),
/// and choose the label with the highest occurrence."
/// </remarks>
/// <see href="http://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm" />
/// </summary>
/// <param name="distanceType">The type of equation to use when measuring the distance between each data point</param>
/// <param name="input">The matrix row to input; must have the same number of columns as the feature space</param>
/// <param name="featureSpace">The feature space matrix; everything we know</param>
/// <param name="labels">The results for each feature space row; what we call each collection of data points</param>
/// <param name="k">The number of nearest neighbors to include in the voting; the label with the most occurrences in 'k' neighbors wins</param>
/// <returns></returns>
public static string Classify(DistanceType distanceType, Number[] input, Matrix featureSpace, IList <string> labels, int k)
{
if (labels.Count() != featureSpace.Rows)
{
throw new ArgumentException("The number of labels must match the number of rows of data in the feature space", "labels");
}
var distances = CalculateDistances(distanceType, featureSpace, input);
var nearestNeighbors = distances.OrderByDescending(d => d.Value).Take(k);
var votes = new Dictionary <string, int>(k);
foreach (var label in nearestNeighbors.Select(neighbor => labels[neighbor.Key]))
{
if (votes.ContainsKey(label))
{
votes[label]++;
}
else
{
votes.Add(label, 1);
}
}
var nearest = votes.OrderByDescending(v => v.Value).First().Key;
return(nearest);
}
private static Dictionary <int, Number> CalculateDistances(DistanceType distanceType, Matrix featureSpace, Number[] input)
{
var distances = new Dictionary <int, Number>(featureSpace.Rows);
for (var i = 0; i < featureSpace.Rows; i++)
{
var features = featureSpace[i];
Number distance = 0;
switch (distanceType)
{
case DistanceType.Euclidean:
distance = Distance.Euclidean(input, features);
break;
case DistanceType.Manhattan:
distance = Distance.Manhattan(input, features);
break;
case DistanceType.Minkowski:
distance = Distance.Minkowski(input, features);
break;
case DistanceType.Hanning:
distance = Distance.Hanning(input, features);
break;
}
distances.Add(i, distance);
}
return(distances);
}
public POICollection GetPOIList(double latitude, double longitude, int distance, DistanceType distanceType)
{
double calculatedDistance;
//convert it back to kilometers
switch (distanceType)
{
case DistanceType.Meters:
calculatedDistance = Convert.ToDouble((double)distance / 1000);
break;
case DistanceType.Miles:
calculatedDistance = distance / 0.621371192;
break;
default:
calculatedDistance = distance;
break;
}
GeoLocation myLocation = GeoLocation.FromDegrees(latitude, longitude);
GeoLocation[] coordinates = myLocation.BoundingCoordinates(calculatedDistance);
double north = coordinates[1].getLatitudeInDegrees();
double south = coordinates[0].getLatitudeInDegrees();
double east = coordinates[1].getLongitudeInDegrees();
double west = coordinates[0].getLongitudeInDegrees();
return GetPOIList(north, south, east, west);
}
private Beacon FromCLBeacon(CLBeacon device)
{
Beacon beacon = new Beacon();
beacon.Minor = device.Minor.Int16Value;
beacon.Major = device.Major.Int16Value;
DistanceType d = DistanceType.UNKNOWN;
switch (device.Proximity)
{
case CLProximity.Immediate:
d = DistanceType.INMEDIATE;
break;
case CLProximity.Near:
d = DistanceType.NEAR;
break;
case CLProximity.Far:
d = DistanceType.FAR;
break;
case CLProximity.Unknown:
break;
}
beacon.Distance = d;
return(beacon);
}
/// <summary>
/// 距离判断
/// </summary>
/// <param name="v1">距离检测1</param>
/// <param name="v2">距离检测2</param>
/// <param name="distanceType">类型</param>
/// <returns></returns>
public static float Distance(Vector3 v1, Vector3 v2, DistanceType distanceType, out float distanceValue)
{
switch (distanceType)
{
case DistanceType.D3D:
return(distanceValue = Vector3.Distance(v1, v2));
case DistanceType.D2D:
//return Vector2.Distance(v1, v2);
Vector2 v21 = Camera.main.WorldToScreenPoint(v1);
Vector2 v22 = Camera.main.WorldToScreenPoint(v2);
float zoom = 750 / Mathf.Sqrt(Mathf.Pow(1920, 2) + Mathf.Pow(1080, 2));
zoom = Mathf.Sqrt(Mathf.Pow(Screen.height, 2) + Mathf.Pow(Screen.width, 2)) * zoom;
return(distanceValue = Vector3.Distance(v21, v22) / zoom);
case DistanceType.DScreen:
Vector3 screen1 = MUtility.MainCamera.WorldToScreenPoint(v1);
Vector3 screen2 = MUtility.MainCamera.WorldToScreenPoint(v2);
return(distanceValue = Vector2.Distance(screen1, screen2));
default:
return(distanceValue = -1);
}
}
/// <inheritdoc/>
public override void UpdateContextMenu()
{
base.UpdateContextMenu();
deployedCableLengthMenuInfo = DistanceType.Format(
cableJoint != null ? cableJoint.deployedCableLength : 0);
PartModuleUtils.SetupEvent(this, ToggleExtendCableEvent, e => {
e.active = linkState != LinkState.NodeIsBlocked;
e.guiName = motorTargetSpeed > float.Epsilon
? StopExtendingMenuTxt
: ExtendCableMenuTxt;
});
PartModuleUtils.SetupEvent(this, ToggleRetractCableEvent, e => {
e.active = linkState != LinkState.NodeIsBlocked;
e.guiName = motorTargetSpeed < -float.Epsilon
? StopRetractingMenuTxt
: RetractCableMenuTxt;
});
PartModuleUtils.SetupEvent(this, InstantStretchEvent, e => {
e.active = !isConnectorLocked && linkState != LinkState.NodeIsBlocked;
});
PartModuleUtils.SetupEvent(this, ReleaseCableEvent, e => {
e.active = linkState != LinkState.NodeIsBlocked;
});
}
private void FillGraphWithEarthMapAsync(Graph graph, DistanceType distanceType)
{
var routes = routerFinderServices.GetRoutesDapper();
var vertexes = routerFinderServices.GetVertexesDapper();
try
{
if (vertexes != null)
{
foreach (var item in vertexes)
{
Node n = new Node(item.IATA3, null, Convert.ToDouble(item.Latitute), Convert.ToDouble(item.Longitude));
graph.AddNode(n);
}
}
}
catch (Exception ex) {
throw new Exception(ex.Message);
}
if (routes != null)
{
foreach (var item in routes)
{
var nodeOrigin = graph.Nodes[item.origin];
var nodeDestination = graph.Nodes[item.Destination];
graph.AddUndirectedEdge(nodeOrigin, nodeDestination, Haversine.Distance(nodeOrigin, nodeDestination, distanceType));
}
}
}
public List<Distancing.Distance> GetLookupTable(DistanceType Type)
{
if(Type.Equals(DistanceType.AVG))
return GetLookupTable_AVG();
else
return GetLookupTable_DFT();
}
public BoolAStar(ref byte[,] byteArray, Point start, Point end, DistanceType distanceType)
{
this.start = start;
this.end = end;
this.distanceType = distanceType;
CreateMap(ref byteArray);
}
internal static extern void cvFitLine(
Arr points,
DistanceType dist_type,
double param,
double reps,
double aeps,
[Out] float[] line);
/// Returns -1 if no valid targets
public int FindTarget(Controller targeter, DistanceType distanceType, TargetType targetType)
{
int targetIndex = -1;
float targetDistance = distanceType == DistanceType.NEAREST ? 0 : float.PositiveInfinity;
for (int i = 0; i < bots.Count; ++i)
{
TargetType type = bots[i].TeamID == targeter.TeamID
? TargetType.ALLY
: TargetType.ENEMY;
if (bots[i] != targeter && targetType == type && !bots[i].Health.Disabled)
{
if (targetIndex == -1)
{
targetIndex = i;
targetDistance = Util.Distance(targeter.transform.position, bots[i].transform.position);
}
else
{
float distance = Util.Distance(targeter.transform.position, bots[i].transform.position);
if (distanceType == DistanceType.NEAREST
? distance <targetDistance : distance> targetDistance)
{
targetIndex = i;
targetDistance = distance;
}
}
}
}
return(targetIndex);
}
internal static extern void cvDistTransform(
Arr src,
Arr dst,
DistanceType distance_type,
int mask_size,
float[] mask,
Arr labels,
DistanceLabel labelType);
static void Main(string[] args)
{
do
{
Grafo graph = new Grafo();
FillGraphWithGridMap(graph);
DistanceType distanceType = DistanceType.km;
// Prints on the screen the distance from a city to its neighbors.
// Used mainly for debug information.
DistanceBetweenNodes(graph, DistanceType.km);
Console.WriteLine("Essas são as cidades que você pode escolher como Origem e Destino na Roménia: \n");
// Prints on screen the cities that you can choose as Start and Destination.
foreach (Node n in graph.Nodes.Cast <Node>().OrderBy(n => n.Key))
{
Console.WriteLine(n.Key);
}
string startCity = GetStartCity(graph);
string destinationCity = GetDestinationCity(graph);
Node start = graph.Nodes[startCity];
Node destination = graph.Nodes[destinationCity];
// Function which tells us the exact distance between two neighbours.
Func <Node, Node, double> distance = (node1, node2) =>
node1.Neighbors.Cast <Vertices>().Single(
etn => etn.Neighbor.Key == node2.Key).Cost;
// Estimation/Heuristic function (Haversine distance)
// It tells us the estimated distance between the last node on a proposed path and the destination node.
Func <Node, double> haversineEstimation =
n => Haversine.Distance(n, destination, DistanceType.km);
Caminho <Node> shortestPath = FindPath(start, destination, distance, haversineEstimation);
Console.WriteLine("\nEste é o menor caminho baseado no algoritmo de busca A*:\n");
// Prints the shortest path.
foreach (Caminho <Node> path in shortestPath.Reverse())
{
if (path.PreviousSteps != null)
{
Console.WriteLine(string.Format("De {0, -15} para {1, -15} -> Custo total = {2:#.###} {3}",
path.PreviousSteps.LastStep.Key, path.LastStep.Key, path.TotalCost, distanceType));
}
}
Console.Write("\nDeseja buscar novamente? Sim/Não? ");
}while (Console.ReadLine().ToLower() == "sim");
}
internal static extern float cvCalcEMD2(
Arr signature1,
Arr signature2,
DistanceType distance_type,
CvDistanceFunction distance_func,
Arr cost_matrix,
Arr flow,
ref float lower_bound,
IntPtr userdata);
//This method to check a given sectorTime is of type distanceTypeName or not.
private bool SectorTimeCheckByDistanceTypeName(double sectorTime, DistanceType distancetype)
{
//var distancetype = GetDistanceType(distanceTypeName);
return
(SectorTimeCheckByConverStringToOperator(distancetype.UpperOperator, sectorTime, distancetype.UpperSectorTime)
&&
SectorTimeCheckByConverStringToOperator(distancetype.LowerOperator, sectorTime, distancetype.LowerSectorTime));
}
/// <summary>
/// 入力画像中の値が0でないピクセルから，最も近い値が0のピクセルまでの距離を計算する
/// </summary>
/// <param name="src">入力画像（8ビット，シングルチャンネル，2値画像）</param>
/// <param name="dst">距離計算結果をピクセル値として持つ出力画像 （32ビット浮動小数点型，シングルチャンネル）</param>
/// <param name="distanceType">距離の種類．L1, L2, C か User</param>
/// <param name="maskSize">距離変換マスクのサイズで，3，5，0 のいずれか． L1，C の場合，このパラメータ値は3に固定される．mask_size==0の場合，距離計算に別の近似無しアルゴリズムが用いられる．</param>
/// <param name="mask">ユーザ定義の距離の場合はユーザ定義のマスク．3×3のマスクを用いる場合は2つの値（上下シフト値，斜めシフト値）を指定，5×5のマスクを用いる場合は3つの値（上下シフト値，斜めシフト値，ナイト移動シフト値（桂馬飛びのシフト値））を指定する．</param>
/// <param name="labels">オプション出力．整数ラベルに変換された2次元配列で，src ，dstと同じサイズ．現在は mask_size==3 あるいは 5 のときのみに使用される．</param>
/// <param name="labelType"></param>
#else
/// <summary>
/// Calculates distance to closest zero pixel for all non-zero pixels of source image.
/// </summary>
/// <param name="src">Source 8-bit single-channel (binary) image. </param>
/// <param name="dst">Output image with calculated distances (32-bit floating-point, single-channel). </param>
/// <param name="distanceType">Type of distance. </param>
/// <param name="maskSize">Size of distance transform mask; can be 3, 5 or 0. In case of CV_DIST_L1 or CV_DIST_C the parameter is forced to 3, because 3×3 mask gives the same result as 5x5 yet it is faster. When mask_size==0, a different non-approximate algorithm is used to calculate distances. </param>
/// <param name="mask">User-defined mask in case of user-defined distance, it consists of 2 numbers (horizontal/vertical shift cost, diagonal shift cost) in case of 3x3 mask and 3 numbers (horizontal/vertical shift cost, diagonal shift cost, knight’s move cost) in case of 5x5 mask. </param>
/// <param name="labels">The optional output 2d array of labels of integer type and the same size as src and dst, can now be used only with mask_size==3 or 5. </param>
/// <param name="labelType"></param>
#endif
public static void DistTransform(CvArr src, CvArr dst, DistanceType distanceType, int maskSize, float[] mask, CvArr labels, DistTransformLabelType labelType)
{
if (src == null)
throw new ArgumentNullException("src");
if (dst == null)
throw new ArgumentNullException("dst");
IntPtr labelsPtr = (labels == null) ? IntPtr.Zero : labels.CvPtr;
NativeMethods.cvDistTransform(src.CvPtr, dst.CvPtr, distanceType, maskSize, mask, labelsPtr, labelType);
}
/// <summary>
/// Khởi tạo cho thuật toán, dùng khi xây dựng cluster từ tập mẫu
/// </summary>
/// <param name="numCluster">Số cluster muốn tạo</param>
/// <param name="samples">Các vector mẫu</param>
/// <param name="distType">Loại khoảng cách</param>
public Clustering(int numCluster, double[][] samples, DistanceType distType)
{
SampleData = new SampleSet(samples, distType);
Clusters = new Cluster[numCluster];
for (int i = 0; i < numCluster; i++)
{
Clusters[i] = new Cluster(samples[0].Length);
}
HasClusterChanged = true;
}
/// <summary>
/// Khởi tạo cho thuật toán, dùng khi xây dựng cluster từ tập mẫu
/// </summary>
/// <param name="numCluster">Số cluster muốn tạo</param>
/// <param name="samples">Các vector mẫu</param>
/// <param name="distType">Loại khoảng cách</param>
public Clustering(int numCluster, double[][] samples, DistanceType distType)
{
SampleData = new SampleSet(samples, distType);
Clusters = new Cluster[numCluster];
for (int i = 0; i < numCluster; i++)
{
Clusters[i] = new Cluster(samples[0].Length);
}
HasClusterChanged = true;
}
private void AddShootEffect(DistanceType type, Position origin,
Position destination, ThingSet tSet)
{
gameMap.GetThingsInVicinity(origin, tSet);
gameMap.GetThingsInVicinity(destination, tSet);
foreach (Thing thing in tSet.GetThings())
{
thing.AddShootEffect((byte)type, origin, destination);
}
}
public double CalculateDistance(Position position1, Position position2, DistanceType distanceType)
{
var R = (distanceType == DistanceType.Miles) ? EarthRadiusInMiles : EarthRadiusInKilometers;
var dLat = angleConverter.ConvertDegreesToRadians(position2.Latitude) - angleConverter.ConvertDegreesToRadians(position1.Latitude);
var dLon = angleConverter.ConvertDegreesToRadians(position2.Longitude) - angleConverter.ConvertDegreesToRadians(position1.Longitude);
var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Cos(angleConverter.ConvertDegreesToRadians(position1.Latitude)) * Math.Cos(angleConverter.ConvertDegreesToRadians(position2.Latitude)) * Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
var c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
var distance = c * R;
return(Math.Round(distance, 2));
}
/// <summary>
/// Uses the Haversine formula to calculate the distance between two locations
/// </summary>
/// <param name="pos1"></param>
/// <param name="pos2"></param>
/// <param name="type"></param>
/// <returns></returns>
public double Distance(GeocodedPosition PositionA, GeocodedPosition PositionB, DistanceType type)
{
double r = (type.Equals(DistanceType.Miles)) ? earthRadiusMiles : earthRadiusKilometers;
double dLat = ToRadian(PositionB.Latitude - PositionA.Latitude);
double dLon = ToRadian(PositionB.Longitude - PositionA.Longitude);
double a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Cos(ToRadian(PositionA.Latitude)) * Math.Cos(ToRadian(PositionB.Latitude)) * Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
double c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
double d = r * c;
return(d);
}
private void FillGraphWithNode(Graph graph, DistanceType distanceType)
{
connection = new DBConnect();
listNodes = connection.getNodes();
for (int i = 0; i < listNodes.Count; i++)
{
Node node = new Node(listNodes[i].getNodeId(), null, listNodes[i].getLatitude(), listNodes[i].getLongitude());
graph.AddNode(node);
}
FillGraphWithEdge(graph);
}
/// <summary>
/// Renders javascript to set distance type and unit.
/// </summary>
/// <remarks>The distance type and unit are then added to the URL to be used on the server.</remarks>
/// <param name="writer">HtmlTextWriter</param>
protected override void RenderJS(HtmlTextWriter writer)
{
// Since this is runtime behavior do it only if there is context.
RenderJS(writer, ClientCommand, "ImgTool");
writer.AddAttribute("language", "javascript");
writer.AddAttribute(HtmlTextWriterAttribute.Type, "text/javascript");
writer.RenderBeginTag(HtmlTextWriterTag.Script);
writer.WriteLine(string.Format("{0}Cmd.distanceType = '{1}';", UniqueID, DistanceType.ToString()));
writer.WriteLine(string.Format("{0}Cmd.distanceUnit = '{1}';", UniqueID, DistanceUnit.ToString()));
writer.RenderEndTag();
}
/// <summary>
/// Distances to.
/// </summary>
/// <param name="lat">The lat.</param>
/// <param name="lng">The LNG.</param>
/// <param name="dType">Type of the d.</param>
/// <returns>System.Double.</returns>
public double DistanceTo(double lat, double lng, DistanceType dType)
{
double R = (dType == DistanceType.Miles) ? EarthRadiusInMiles : EarthRadiusInKilometers;
double dLat = DegreeToRadian(lat) - DegreeToRadian(this.latitude);
double dLon = DegreeToRadian(lng) - DegreeToRadian(this.longitude);
double a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Cos(DegreeToRadian(this.latitude)) * Math.Cos(DegreeToRadian(lat)) * Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
double c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
double distance = c * R;
return(Math.Round(distance, 2));
} // end DistanceTo
/// <summary>
/// Initializes a Distance object based on a specified distance and measurement type.
/// </summary>
/// <param name="distance">Distance</param>
/// <param name="type">Measurement type</param>
/// <example>
/// The following example converts meters into miles.
/// <code>
/// Distance distance = new Distance(1000.36, DistanceType.Meters);
/// Console.WriteLine(distance.Miles); //0.62159469356
/// </code>
/// </example>
public Distance(double distance, DistanceType type)
{
bearing = 0;
switch (type)
{
case DistanceType.Feet:
feet = distance;
meters = feet * 0.3048;
kilometers = meters / 1000;
miles = meters * 0.000621371;
nauticalMiles = meters * 0.0005399565;
break;
case DistanceType.Kilometers:
kilometers = distance;
meters = kilometers * 1000;
feet = meters * 3.28084;
miles = meters * 0.000621371;
nauticalMiles = meters * 0.0005399565;
break;
case DistanceType.Meters:
meters = distance;
kilometers = meters / 1000;
feet = meters * 3.28084;
miles = meters * 0.000621371;
nauticalMiles = meters * 0.0005399565;
break;
case DistanceType.Miles:
miles = distance;
meters = miles * 1609.344;
feet = meters * 3.28084;
kilometers = meters / 1000;
nauticalMiles = meters * 0.0005399565;
break;
case DistanceType.NauticalMiles:
nauticalMiles = distance;
meters = nauticalMiles * 1852.001;
feet = meters * 3.28084;
kilometers = meters / 1000;
miles = meters * 0.000621371;
break;
default:
kilometers = distance;
meters = distance * 1000;
feet = meters * 3.28084;
miles = meters * 0.000621371;
nauticalMiles = meters * 0.0005399565;
break;
}
}
void FormatFixed()
{
#region CompactNumberType2_FormatFixed
Debug.Log(DistanceType.Format(1234.5678, format: "0.0000"));
// Prints: "1234.5678"
Debug.Log(DistanceType.Format(1234.5678, format: "0.00"));
// Prints: "1234.57"
Debug.Log(DistanceType.Format(1234.5678, format: "#,##0.00"));
// Prints: "1,234.57"
#endregion
}
/// <summary>
/// Returns the distance in miles or kilometers of any two
/// latitude / longitude points.
/// </summary>
/// <param name=”pos1″></param>
/// <param name=”pos2″></param>
/// <param name=”type”></param>
/// <returns>Distance</returns>
public double Distance(Position pos1, Position pos2, DistanceType type)
{
double R = (type == DistanceType.Miles) ? 3960 : 6371;
double dLat = this.toRadian(pos2.Latitude - pos1.Latitude);
double dLon = this.toRadian(pos2.Longitude - pos1.Longitude);
double a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
Math.Cos(this.toRadian(pos1.Latitude)) * Math.Cos(this.toRadian(pos2.Latitude)) *
Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
double c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
double d = R * c;
return d;
}
public SampleSet(double[][] input, DistanceType type)
{
Samples = input;
DistanceToClusters = new double[input.Length];
ClusterIndices = new int[input.Length];
for(int i = 0;i < DistanceToClusters.Length;i++)
{
DistanceToClusters[i] = -1;
ClusterIndices[i] = -1;
}
DistType = type;
}
/// <summary>
/// Returns the distance in miles or kilometers of any two
/// latitude / longitude points.
/// </summary>
public static double DistanceBetween(XLocation pos1, XLocation pos2, DistanceType type)
{
double R = (type == DistanceType.Miles) ? 3960 : 6371;
double dLat = _toRadian(pos2.Latitude - pos1.Latitude);
double dLon = _toRadian(pos2.Longitude - pos1.Longitude);
double a = Math.Sin(dLat/2)*Math.Sin(dLat/2) +
Math.Cos(_toRadian(pos1.Latitude))*Math.Cos(_toRadian(pos2.Latitude))*
Math.Sin(dLon/2)*Math.Sin(dLon/2);
double c = 2*Math.Asin(Math.Min(1, Math.Sqrt(a)));
double d = R*c;
return d;
}
public static float Distance(float latA, float lonA, float latB, float lonB, DistanceType type)
{
float R = (type == DistanceType.Miles) ? 3960 : 6371;
float fLat = toRadian(latB - latA);
float fLon = toRadian(lonB - lonA);
float a = Mathf.Sin(fLat / 2) * Mathf.Sin(fLat / 2) + Mathf.Cos(toRadian(latA)) * Mathf.Cos(toRadian(latB)) * Mathf.Sin(fLon / 2) * Mathf.Sin(fLon / 2);
float c = 2 * Mathf.Asin(Mathf.Min(1, Mathf.Sqrt(a)));
float d = R * c;
return d;
}
/// <summary>
/// Returns the distance in miles or kilometers of any two
/// latitude / longitude points.
/// </summary>
/// <param name="pos1">The pos1.</param>
/// <param name="pos2">The pos2.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
public static double Distance(Position pos1, Position pos2,DistanceType type)
{
double r = (type == DistanceType.Miles) ? 3960 : 6371;
var dLat = ToRadian(pos2.Latitude - pos1.Latitude);
var dLon = ToRadian(pos2.Longitude - pos1.Longitude);
var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
Math.Cos(ToRadian(pos1.Latitude)) *Math.Cos(ToRadian(pos2.Latitude)) *
Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
var c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
var d = r * c;
return d;
}
public static DirectionsResponse Directions(double[] origin, double[] destination, DistanceType type, DistanceUnit unit, bool sensor)
{
string url = APIUrl + "directions/json";
string[] parameters = { "origin", "destination", "mode", "units", "sensor" };
string[] values = {
origin[0].ToString() + "," + origin[1].ToString() ,
destination[0].ToString() + "," + destination[1].ToString(),
type.ToString(),
unit.ToString(),
((sensor) ? "true" : "false")
};
ArrayList headers = new ArrayList();
string response = Utils.Request.ReadResponse(Utils.Request.Get(url, Encoding.UTF8, parameters, values, headers), Encoding.UTF8);
DirectionsResponse dr = jss.Deserialize<DirectionsResponse>(response);
return dr;
}
/// <summary>
/// Returns the distance in miles or kilometers of any two
/// latitude / longitude points.
/// </summary>
/// <param name=”node1″></param>
/// <param name=”node2″></param>
/// <param name=”type”></param>
/// <returns></returns>
public static double Distance(Node node1, Node node2, DistanceType type)
{
double R = (type == DistanceType.ml) ? 3960 : 6371;
double dLat = ToRadian(node2.Latitude - node1.Latitude);
double dLon = ToRadian(node2.Longitude - node1.Longitude);
double a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
Math.Cos(ToRadian(node1.Latitude)) * Math.Cos(ToRadian(node2.Latitude)) *
Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
double c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
double d = R * c;
return d;
}
public Node(Point location, byte cost, Point start, Point end, DistanceType distanceType = DistanceType.Chebyshev)
{
this.location = location;
this.cost = cost;
switch (distanceType)
{
case DistanceType.Octile:
g = OHeuristic(end);
h = OHeuristic(start);
break;
case DistanceType.Chebyshev:
g = CHeuristic(end);
h = CHeuristic(start);
break;
case DistanceType.Manhattan:
g = MHeuristic(end);
h = MHeuristic(start);
break;
}
}
internal Sartin(BrisPastPerformance pp)
{
_firstFraction = pp.SpeedDuringFirstFraction * Utilities.FEET_IN_A_YEARD;
_secondFraction = pp.SpeedDuringSecondFraction * Utilities.FEET_IN_A_YEARD;
_finalFraction = pp.SpeedDuringFinalFraction * Utilities.FEET_IN_A_YEARD;
_earlyPace = pp.SpeedFromStartToSecondCall * Utilities.FEET_IN_A_YEARD;
int distance = pp.DistanceInYards;
if (distance <= 0)
{
_distanceType = DistanceType.Invalid;
}
else if (distance <= Utilities.YARDS_IN_A_FURLONG * 7)
{
_distanceType = DistanceType.Sprint;
}
else
{
_distanceType = DistanceType.Route;
}
}
/// <summary>
/// Returns the unit abbreviation for a particular distance type (ft, km, mi, etc.)
/// </summary>
/// <param name="distanceType">Distance type to get abbreviation for</param>
/// <returns>Two character lower case abbreviation for a distance type</returns>
public static string Unit(DistanceType distanceType)
{
return _shortAbbrev[(int)distanceType];
}
/// <summary>
/// Create a GPUBruteForce Matcher using the specific distance type
/// </summary>
/// <param name="distType">The distance type</param>
public GpuBruteForceMatcher(DistanceType distType)
{
_distanceType = distType;
_ptr = gpuBruteForceMatcherCreate(distType);
}
/// <summary>
/// Fits line to the set of 3D points using M-estimator algorithm.
/// The input is vector of 3D points.
/// </summary>
/// <param name="distType">Distance used by the M-estimator</param>
/// <param name="param">Numerical parameter ( C ) for some types of distances.
/// If it is 0, an optimal value is chosen.</param>
/// <param name="reps">Sufficient accuracy for the radius
/// (distance between the coordinate origin and the line).</param>
/// <param name="aeps">Sufficient accuracy for the angle.
/// 0.01 would be a good default value for reps and aeps.</param>
/// <returns>Output line parameters.</returns>
public CvLine3D FitLine3D(DistanceType distType, double param, double reps, double aeps)
{
var line = new MatOfFloat();
Cv2.FitLine(this, line, distType, param, reps, aeps);
return new CvLine3D(line.ToArray());
}
/* public List<Distancing.Distance> GetLookupTable_AVG(Axis axis)
{
List<Distancing.Distance> Output = new List<Distancing.Distance>();
//this pulls a distinct list of the distance points in the DB
foreach (int Dist in this.LookupData.Select(d => d.Distance).Distinct())
{
//decimal AvgI = (decimal)this.LookupData.Where(d => d.Distance.Equals(Dist)&& d.reciver.equals((int)axis)).Select(d => d.I).Average();
//decimal AvgQ = (decimal)this.LookupData.Where(d => d.Distance.Equals(Dist)&& d.reciver.equals((int)axis)).Select(d => d.Q).Average();
int count = this.LookupData.Where(d => d.Distance.Equals(Dist)).Count();
Output.Add(new Distancing.Distance()
{
Dist = Dist,
I = AvgI,
Q = AvgQ,
NumberofReads = count
});
}
return Output;
}
*/
public List<Distancing.Distance> GetLookupTable(DistanceType Type)
{
return GetLookupTable_DFT();
}
/// <summary>
/// Create a BruteForceMatcher of the specific distance type
/// </summary>
/// <param name="distanceType">The distance type</param>
public BruteForceMatcher(DistanceType distanceType)
{
_distanceType = distanceType;
_ptr = CvBruteForceMatcherCreate(_distanceType);
}
private static extern void CvBruteForceMatcherRelease(ref IntPtr matcher, DistanceType distanceType);
public static extern void cvDistTransform(IntPtr src, IntPtr dst, DistanceType distanceType, int mask_size, float[] user_mask, IntPtr labels);
/// <summary>
/// Returns the full unit name (in English) for a particular distance time (km, ft., m)
/// </summary>
/// <param name="distanceType">Distance type to get abbreviation for</param>
/// <returns>Lower case abbreviation for a distance type</returns>
public static string Abbreviation(DistanceType distanceType)
{
return _shortAbbrev[(int)distanceType];
}
/// <summary>
/// Parse a string.
/// </summary>
/// <param name="distance">String of valid numeric characters</param>
/// <param name="distanceType">Distance type string represents (inches, miles, kilometers)</param>
/// <returns>New DistanceSpan</returns>
public static DistanceSpan Parse(string distance, DistanceType distanceType)
{
return new DistanceSpan(double.Parse(distance, CultureInfo.InvariantCulture), distanceType);
}
private static extern IntPtr gpuBruteForceMatcherCreate(DistanceType distType);
public static double FromMetric(double meters, DistanceType outputType)
{
double _retval = 0D;
switch (outputType)
{
case DistanceType.MileNautical: _retval = meters / GeoConstant.METERSINNMILE;
break;
case DistanceType.Mile: _retval = meters / GeoConstant.METERSINMILE;
break;
case DistanceType.Yard: _retval = meters / GeoConstant.METERSINYARD;
break;
case DistanceType.Inch: _retval = meters / GeoConstant.METERSININCH;
break;
case DistanceType.Foot: _retval = meters / GeoConstant.METERSINFOOT;
break;
case DistanceType.Kilometer: _retval = meters / 1000D;
break;
case DistanceType.Meter: _retval = meters;
break;
case DistanceType.Centimeter: _retval = meters * 100D;
break;
case DistanceType.Millimeter: _retval = meters * 1000D;
break;
default:
throw new ArgumentException("DistanceType not supported");
}
return _retval;
}
/// <summary>
/// Returns the full unit name (in English) for a particular distance span (kilometer, feet, mile)
/// </summary>
/// <param name="distance">Distance value to get name for</param>
/// <param name="distanceType">Distance type to get name for</param>
/// <returns>Lower case full name for a distance type</returns>
public static string Name(DistanceSpan distance, DistanceType distanceType)
{
return (Math.Abs(distance._meters)<1)?_nameSingular[(int)distanceType]:_namePlural[(int)distanceType];
}
/// <summary>
/// Convert a distance from one type to another
/// </summary>
/// <param name="value">Distance to convert</param>
/// <param name="inputType">Type that value represents</param>
/// <param name="outputType">Target type the return value represents</param>
/// <returns>Converted distance that is of outputType</returns>
public static double Convert(double value, DistanceSpan.DistanceType inputType, DistanceType outputType)
{
return FromMetric(ToMetric(value, inputType), outputType);
}
