/// <summary>
/// 合并系统车场和百度车场
/// </summary>
/// <param name="parks"></param>
/// <param name="result"></param>
/// <returns></returns>
private List <BaiDuParkingLocation> MergeParking(List <BaseParkinfo> parks, BaiDuParking result)
{
List <BaiDuParkingLocation> models = new List <BaiDuParkingLocation>();
if (result.IsSuccess)
{
foreach (var item in result.results)
{
bool needExclude = false;
foreach (var park in parks)
{
if (string.IsNullOrWhiteSpace(park.Coordinate) || !park.Coordinate.Contains(','))
{
continue;
}
var lats = park.Coordinate.Split(',');
var distance = XY.DistanceTo(item.location.lat.ToDouble(), item.location.lng.ToDouble(), lats[0].ToDouble(), lats[1].ToDouble());
if (distance <= 100)
{
needExclude = true;
break;
}
}
if (!needExclude)
{
BaiDuParkingLocation model = new BaiDuParkingLocation();
model.id = item.uid;
model.street_id = item.street_id;
model.uid = item.uid;
model.lat = item.location.lat;
model.lng = item.location.lng;
model.name = item.name;
model.address = item.address;
model.type = 1;
models.Add(model);
}
}
}
foreach (var park in parks)
{
if (string.IsNullOrWhiteSpace(park.Coordinate) || !park.Coordinate.Contains(','))
{
continue;
}
var lats = park.Coordinate.Split(',');
BaiDuParkingLocation model = new BaiDuParkingLocation();
model.id = park.PKID.ToString();
model.quantity = park.SpaceBitNum;
model.lat = lats[0];
model.lng = lats[1];
model.name = park.PKName;
model.address = park.Address;
model.type = 0;
models.Add(model);
}
return(models);
}
/// <summary> 从递增的局部序列中选出一个点来 </summary>
/// <param name="startIndex">局部序列的起始下标</param>
/// <param name="endIndex">局部序列的终止下标</param>
/// <returns>选出来的那一个点在整个曲线集合中的下标</returns>
private int PickOneByXAxis(int startIndex, int endIndex)
{
int[] indice = ArrayConstructor.FromRangeAri(startIndex, endIndex, 1);
bool ascend = true;
// 如果 indice 中
int count = indice.Length;
switch (count)
{
case 0:
{
throw new ArgumentException(@"集合中必须有至少一个元素。");
}
case 1:
{
return(indice[0]);
}
case 2:
{
if (ascend)
{
return(indice[1]);
}
else
{
return(indice[0]);
}
}
default: // 此时集合中的元素个数至少为 3 个
{
bool considerDistance = false; // 是否以每两个相邻点之间的距离作为参考指标
if (!considerDistance)
{
if (ascend)
{
// 直接返回子集合中的最后一个
return(indice[count - 1]);
}
else
{
// 直接返回子集合中的第一个
return(indice[0]);
}
}
else
{
var distances = new List <double>();
XY lastPoint = new XY(_xValues[indice[0]], _yValues[indice[0]]);
XY nextPoint;
// 提取出每两个点之间的距离
for (int i = 1; i < count; i++)
{
nextPoint = new XY(_xValues[indice[i]], _yValues[indice[i]]);
distances.Add(nextPoint.DistanceTo(lastPoint));
//
lastPoint = nextPoint;
}
// 找出距离最小的两个点的下标{ minLeft,minLeft+1 }
double minDist = double.MaxValue;
int minLeft = indice[0]; // 距离最小的那一段的两个点中靠左边的那个点在整条曲线中的绝对下标值
for (int i = 0; i < distances.Count; i++)
{
if (distances[i] <= minDist)
{
minDist = distances[i];
minLeft = i + indice[0];
}
}
// 取距离最小的两个点{ minLeft,minLeft+1 }中的一个
if (ascend) // 总思路为：在无法比较时，都趋向于选择向右边的点
{
// 基本原则为： 如果为最前面两个，则取第2个；如果为最后两个，则取最后一个；如果为中间的某一小段，则取向两边各扩展一个点后比较哪个更密。
if (minLeft == indice[0])
{
return(indice[1]);
}
else if (minLeft == indice[count - 2])
{
return(indice[count - 1]);
}
else
{
// indice 中至少有4个点，而 minLeft 为第2个到第 count - 2 个。
// 向两边各扩展一个点后比较哪个更密。
if (distances[minLeft - indice[0] - 1] >= distances[minLeft - indice[0] + 1])
{
// 取靠右边的那个
return(minLeft + 1);
}
else
{
// 取靠左边的那个
return(minLeft);
}
}
}
else // 整条曲线的X序列为降序时，总思路为：在无法比较时，都趋向于选择向左边的点
{
// 基本原则为： 如果为最前面两个，则取第1个；如果为最后两个，则取倒数第二个；如果为中间的某一小段，则取向两边各扩展一个点后比较哪个更密。
if (minLeft == indice[0])
{
return(indice[0]);
}
else if (minLeft == indice[count - 2])
{
return(indice[count - 2]);
}
else
{
// indice 中至少有4个点，而 minLeft 为第2个到第 count - 2 个。
// 向两边各扩展一个点后比较哪个更密。
if (distances[minLeft - indice[0] - 1] <= distances[minLeft - indice[0] + 1])
{
// 取靠左边的那个
return(minLeft);
}
else
{
// 取靠右边的那个
return(minLeft + 1);
}
}
}
}
} // 此时集合中的元素个数至少为 3 个
}
}
