yangyakun921/MoGoEagleEye
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[646]feat:增加全局轨迹绘制；

Browse Source
This commit is contained in:
aibingbing
2024-06-21 18:59:28 +08:00
parent e528da6fc9
commit 1ffcee57f2
5 changed files with 562 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/function-impl/mogo-core-function-map/src/main/java/com/mogo/eagle/core/function/MapBizProvider.kt
View File

@@ -11,6 +11,7 @@ import com.mogo.eagle.core.function.business.SpeedLimitDataManager
import com.mogo.eagle.core.function.business.ai.AiCloudIdentifyDataManager.Companion.aiCloudIdentifyDataManager
import com.mogo.eagle.core.function.business.identify.MapIdentifySubscriber
import com.mogo.eagle.core.function.business.routeoverlay.MogoRouteOverlayManager
import com.mogo.eagle.core.function.business.trajectoryoverlay.MogoTrajectoryOverlayManager
import com.mogo.eagle.core.function.call.map.CallerVisualAngleManager
import com.mogo.eagle.core.utilcode.util.DeviceUtils
import com.mogo.map.MapDataWrapper
@@ -25,6 +26,7 @@ class MapBizProvider :IMoGoFunctionServerProvider, IMogoRoma {
MapDataWrapper.init()
MapIdentifySubscriber.instance
MogoRouteOverlayManager.getInstance().init()
MogoTrajectoryOverlayManager.getInstance().init()
MapPointCloudSubscriber.instance
SpeedLimitDataManager.getInstance().start()
if(DeviceUtils.isLenovoModel() || DeviceUtils.isEB5Model()){ //todo 新增稳定设备类型需要添加，目的避免在nuc设备上使用此类功能

85
core/function-impl/mogo-core-function-map/src/main/java/com/mogo/eagle/core/function/business/trajectoryoverlay/MogoTrajectoryOverlayManager.java Normal file
View File

@@ -0,0 +1,85 @@
package com.mogo.eagle.core.function.business.trajectoryoverlay;
import androidx.annotation.Nullable;
import com.mogo.eagle.core.data.map.MogoLocation;
import com.mogo.eagle.core.function.api.autopilot.IMoGoChassisLocationGCJ02Listener;
import com.mogo.eagle.core.function.api.autopilot.IMoGoPlanningRottingListener;
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager;
import com.mogo.eagle.core.function.call.autopilot.CallerChassisLocationGCJ02ListenerManager;
import com.mogo.eagle.core.function.call.autopilot.CallerPlanningRottingListenerManager;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import java.util.LinkedList;
import java.util.List;
import mogo.telematics.pad.MessagePad;
public class MogoTrajectoryOverlayManager implements
IMoGoPlanningRottingListener,
IMoGoChassisLocationGCJ02Listener {
private static volatile MogoTrajectoryOverlayManager sInstance;
private static final String TAG = "MogoTrajectoryOverlayManager";
private final LinkedList<List<MessagePad.Location>> queue = new LinkedList<>();
private MogoTrajectoryOverlayManager() {
}
public void init() {
CallerPlanningRottingListenerManager.INSTANCE.addListener(TAG, this);
CallerChassisLocationGCJ02ListenerManager.INSTANCE.addListener(TAG, 1,this);
}
public static MogoTrajectoryOverlayManager getInstance() {
if (sInstance == null) {
synchronized (MogoTrajectoryOverlayManager.class) {
if (sInstance == null) {
sInstance = new MogoTrajectoryOverlayManager();
}
}
}
return sInstance;
}
@Override
public void onAutopilotRotting(@Nullable MessagePad.GlobalPathResp globalPathResp) {
CallerLogger.i(TAG, "onAutopilotRotting size="+globalPathResp.getWayPointsList().size());
if (globalPathResp != null) {
synchronized (queue) {
queue.clear();
queue.offer(globalPathResp.getWayPointsList());
}
}
}
@Override
public void onChassisLocationGCJ02(@Nullable MogoLocation gnssInfo) {
if (gnssInfo == null) {
return;
}
int autoPilotState = CallerAutoPilotStatusListenerManager.INSTANCE.getState();
boolean isArriveAtStation = CallerAutoPilotStatusListenerManager.INSTANCE.isArriveAtStation();
// Log.d(TAG, "-- onChassisLocationGCJ02 -- 1 ---" + ":auto-mode:" + autoPilotState + ", isArriveAtStation: " + isArriveAtStation);
// if (isArriveAtStation && autoPilotState != 2) {
// RouteOverlayDrawer.getInstance().clearMogoRouteOverlay();
// return;
// }
// Log.d(TAG, "-- onChassisLocationGCJ02 -- 2 ---" + "auto-mode:" + autoPilotState + ", isDemoMode:" + FunctionBuildConfig.isDemoMode + ", force:" + FunctionBuildConfig.isForceDrawAutopilotTrajectoryByDebugSettingView);
// boolean force = FunctionBuildConfig.isForceDrawAutopilotTrajectoryByDebugSettingView || FunctionBuildConfig.isDemoMode && FunctionBuildConfig.isIgnoreConditionsDrawAutopilotTrajectoryData;
// if (!force && autoPilotState != 2) {
// RouteOverlayDrawer.getInstance().clearMogoRouteOverlay();
// return;
// }
// Log.d(TAG, "-- onChassisLocationGCJ02 -- 3 ---");
synchronized (queue) {
if (!queue.isEmpty()) {
List<MessagePad.Location> items = queue.pollLast();
if (items != null && !items.isEmpty()) {
TrajectoryOverlayDrawer.getInstance().drawTrajectoryList(items, gnssInfo.getHeading());
}
}
}
}
}

301
core/function-impl/mogo-core-function-map/src/main/java/com/mogo/eagle/core/function/business/trajectoryoverlay/TrajectoryOverlayDrawer.java Normal file
View File

@@ -0,0 +1,301 @@
package com.mogo.eagle.core.function.business.trajectoryoverlay;
import static com.mogo.map.MogoMap.DEFAULT;
import android.annotation.SuppressLint;
import android.graphics.Color;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import androidx.core.util.Pools;
import com.mogo.eagle.core.data.map.MogoLatLng;
import com.mogo.eagle.core.function.call.autopilot.CallerChassisLocationWGS84ListenerManager;
import com.mogo.eagle.core.function.call.map.CallerMapUIServiceManager;
import com.mogo.eagle.core.utilcode.util.DrivingDirectionUtils;
import com.mogo.map.overlay.IMoGoOverlayManager;
import com.mogo.map.overlay.core.Level;
import com.mogo.map.overlay.line.Polyline;
import com.zhidaoauto.map.sdk.open.common.tools.MapTools;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import kotlin.Pair;
import mogo.telematics.pad.MessagePad;
public class TrajectoryOverlayDrawer {
private static final String TAG = "TrajectoryOverlayDrawer";
// 连接线参数
private Handler mRenderHandler;
private final IMoGoOverlayManager mogoOverlayManager;
private static volatile TrajectoryOverlayDrawer sInstance;
private static final byte[] obj = new byte[0];
private Polyline.Options mPolylineOptions;
private static final int COLOR_LIGHT = Color.parseColor("#BAEBF5");
//用于taxi乘客屏渐变颜色集合
private static List<Integer> colors = null;
private TrajectoryOverlayDrawer() {
// 渐变色
mogoOverlayManager = CallerMapUIServiceManager.INSTANCE.getOverlayManager();
if (mogoOverlayManager != null) {
mPolylineOptions = new Polyline.Options.Builder("trajectory_overlay", Level.TRAJECTORY_LINE)
.setUseGps(true)
.setWidth(30)
.setIsGradient(true)
.build();
// 线条粗细，渐变，渐变色值
HandlerThread renderTask = new HandlerThread("trajectory_render") {
@Override
protected void onLooperPrepared() {
super.onLooperPrepared();
mRenderHandler = new Handler(getLooper());
}
};
renderTask.start();
}
}
public static TrajectoryOverlayDrawer getInstance() {
if (sInstance == null) {
synchronized (obj) {
if (sInstance == null) {
sInstance = new TrajectoryOverlayDrawer();
}
}
}
return sInstance;
}
public void clearMogoTrajectoryOverlay() {
if (mogoOverlayManager != null) {
if (mRenderTask != null) {
mRenderHandler.removeCallbacks(mRenderTask);
}
mogoOverlayManager.removeAllLinesInLevel(Level.TRAJECTORY_LINE);
}
}
private class RenderTask implements Runnable {
private volatile List<MessagePad.Location> routeList;
private final Pools.Pool<MogoLatLng> pools;
private final LinkedList<MogoLatLng> points;
private double bearing;
public RenderTask() {
this.pools = new Pools.SimplePool<>(500);
this.points = new LinkedList<>();
}
public void setData(List<MessagePad.Location> routeList, double bearing) {
this.routeList = routeList;
this.bearing = bearing;
}
@SuppressLint("LongLogTag")
@Override
public void run() {
IMoGoOverlayManager overlayManager = mogoOverlayManager;
if (overlayManager == null) {
return;
}
LinkedList<MogoLatLng> pps = this.points;
boolean isExcept = false;
int total;
try {
pps.clear();
List<MessagePad.Location> routes = this.routeList;
if (routes == null || (total = routes.size()) < 2) {
isExcept = true;
return;
}
// boolean isColorfulStrategy = !AppIdentityModeUtils.isTaxi(FunctionBuildConfig.appIdentityMode) || !AppIdentityModeUtils.isPassenger(FunctionBuildConfig.appIdentityMode);
//TODO
boolean isColorfulStrategy = false;
if (isColorfulStrategy) {
TrajectoryStrategy.INSTANCE.start();
} else {
if (colors == null) {
ArrayList<Pair<Integer, Integer>> temps = new ArrayList<>();
// temps.add(new Pair<>(0, 51));
// temps.add(new Pair<>(10, 102));
// temps.add(new Pair<>(30, 51));
// temps.add(new Pair<>(100, 0));
temps.add(new Pair<>(0, 51));
temps.add(new Pair<>(10, 51));
temps.add(new Pair<>(30, 51));
temps.add(new Pair<>(100, 51));
List<Integer> alphas = MapTools.INSTANCE.getColorAlpha(temps);
if (alphas != null && !alphas.isEmpty()) {
colors = new ArrayList<>();
for (int i : alphas) {
colors.add(Color.argb(i, 48,203,251));
}
}
}
}
for (int i = 0; i < total; i++) {
MessagePad.Location route = null;
try {
route = routes.get(i);
if (route == null) {
continue;
}
} catch (Throwable t) {
Log.d("Trajectory", "render-error:" + t.getMessage());
}
if (route == null) {
//数组越界了，结束循环
break;
}
MogoLatLng acquire = pools.acquire();
double latitude = route.getLatitude();
double longitude = route.getLongitude();
if (acquire == null) {
acquire = new MogoLatLng(latitude, longitude);
} else {
acquire.lon = longitude;
acquire.lat = latitude;
}
// acquire.acc = route.getAcceleration();
// acquire.speed = route.getVelocity();
pps.add(acquire);
// if (isColorfulStrategy) {
//// RouteStrategy.INSTANCE.check(route.getVelocity(), route.getAcceleration(), routeList.size());
// }
}
double lon = CallerChassisLocationWGS84ListenerManager.INSTANCE.getChassisLocationWGS84().getLongitude();
double lat = CallerChassisLocationWGS84ListenerManager.INSTANCE.getChassisLocationWGS84().getLatitude();
if (points.size() > 0) {
MogoLatLng top = null;
while (points.size() != 0) {
MogoLatLng first = points.peek();
if (first == null) {
continue;
}
if (first == top) {
break;
}
lon = CallerChassisLocationWGS84ListenerManager.INSTANCE.getChassisLocationWGS84().getLongitude();
lat = CallerChassisLocationWGS84ListenerManager.INSTANCE.getChassisLocationWGS84().getLatitude();
long angle = isPointOnCarFront(lon, lat, bearing, first.lon, first.lat);
if (angle >= 90) {
if (isColorfulStrategy) {
TrajectoryStrategy.INSTANCE.remove(first.acc);
}
pools.release(first);
points.poll();
}
top = first;
}
if (points.size() == 0) {
isExcept = true;
return;
}
// MogoLatLng self = pools.acquire();
// if (self == null) {
// self = new MogoLatLng(lat, lon);
// } else {
// self.lat = lat;
// self.lon = lon;
// }
// points.addFirst(self);
Polyline.Options.Builder builder;
if (mPolylineOptions == null) {
builder = new Polyline.Options.Builder("trajectory_overlay", Level.TRAJECTORY_LINE)
.setUseGps(true)
.setWidth(20)
.setIsGradient(true);
} else {
builder = mPolylineOptions.builder();
}
if (isColorfulStrategy) {
TrajectoryStrategy.INSTANCE.end();
Strategy strategy = TrajectoryStrategy.INSTANCE.getStrategy();
List<Integer> colors = strategy.getColors();
boolean isLightOn = strategy instanceof ColorfulStrategy && ((ColorfulStrategy) strategy).isLightOn();
builder.colors(colors);
builder.setLightOn(isLightOn);
builder.setLightColor(COLOR_LIGHT);
builder.setLightSpeed(0.3f);
} else {
if (colors != null && !colors.isEmpty()) {
builder.colors(colors);
builder.setIsGradient(true);
// builder.setLightOn(true);
builder.setLightOn(false);
builder.setLightColor(COLOR_LIGHT);
builder.setLightSpeed(0.3f);
}
}
builder.points(points);
builder.setVisible(true);
Polyline.Options options = builder.build();
if (mPolylineOptions == null) {
mPolylineOptions = options;
}
overlayManager.showOrUpdateLine(options,DEFAULT);
} else {
isExcept = true;
}
} catch (Throwable t) {
t.printStackTrace();
} finally {
if (isExcept) {
setVisible(false);
}
if (points.size() > 0) {
for (int i = 0; i < points.size(); i++) {
MogoLatLng latLng = points.get(i);
if (latLng == null) {
continue;
}
pools.release(latLng);
}
}
}
}
private long isPointOnCarFront(double car_lon, double car_lat, double car_head, double lon, double lat) {
return DrivingDirectionUtils.getDegreeOfCar2Poi2(car_lon, car_lat, lon, lat, car_head);
}
}
private volatile RenderTask mRenderTask;
public void drawTrajectoryList(List<MessagePad.Location> routeList, double bearing) {
if (mogoOverlayManager != null) {
if (mRenderTask == null) {
mRenderTask = new RenderTask();
}
mRenderTask.setData(routeList, bearing);
if (mRenderHandler != null) {
mRenderHandler.removeCallbacks(mRenderTask);
mRenderHandler.post(mRenderTask);
}
}
}
public void setVisible(boolean isVisible) {
if (mogoOverlayManager != null) {
if (isVisible) {
mogoOverlayManager.showAllLinesInLevel(Level.TRAJECTORY_LINE);
} else {
mogoOverlayManager.hideAllLinesInLevel(Level.TRAJECTORY_LINE);
}
}
}
}

169
core/function-impl/mogo-core-function-map/src/main/java/com/mogo/eagle/core/function/business/trajectoryoverlay/TrajectoryStrategy.kt Normal file
View File

@@ -0,0 +1,169 @@
package com.mogo.eagle.core.function.business.trajectoryoverlay
import android.animation.ArgbEvaluator
import android.graphics.Color
import android.view.animation.AccelerateInterpolator
import com.mogo.eagle.core.data.config.HmiBuildConfig
import com.mogo.eagle.core.function.business.routeoverlay.Colors.Companion.COLOR_BLUE
import com.mogo.eagle.core.function.business.routeoverlay.Colors.Companion.COLOR_BLUE_DARK
import com.mogo.eagle.core.function.business.routeoverlay.Colors.Companion.COLOR_RED_DARK
import com.mogo.eagle.core.function.business.routeoverlay.Colors.Companion.COLOR_TRANSPARENT
import java.util.*
import kotlin.properties.Delegates
interface IStrategy {
fun getColors(): List<Int>
}
class Colors {
companion object {
val COLOR_BLUE = Color.parseColor("#FF2ABAD9")
val COLOR_BLUE_DARK = Color.parseColor("#FF074EFF")
val COLOR_RED_DARK = Color.parseColor("#FFFF5F00")
val COLOR_TRANSPARENT = Color.parseColor("#002ABAD9")
}
}
sealed class Strategy : IStrategy
class DefaultStrategy(private val colors: List<Int>? = null) : Strategy() {
override fun getColors(): List<Int> = colors ?: listOf(COLOR_BLUE, COLOR_TRANSPARENT)
}
class ColorfulStrategy(private val colors: List<Int> = emptyList(), var isLightOn: Boolean) :
Strategy() {
override fun getColors(): List<Int> = colors
}
object TrajectoryStrategy {
private var isEnable by Delegates.observable(HmiBuildConfig.isShowRouteStrategy) { _, _, newValue ->
if (!newValue) {
strategy = null
colors.clear()
}
}
private var strategy: Strategy? = null
private val colors: ArrayList<Int> = ArrayList()
private var index = 0
private val sorted: NavigableMap<Double, Int> by lazy { TreeMap() }
private var endEvaluator: ArgbEvaluator? = null
private var startColor = Int.MAX_VALUE
private var hasLessThan0 = false
fun start() {
if (sorted.isEmpty()) {
fill()
}
strategy = null
index = 0
startColor = Int.MAX_VALUE
colors.clear()
endEvaluator = null
hasLessThan0 = false
}
fun end() {
if (isEnable) {
if (colors.isEmpty()) {
return
}
val first = colors[0]
colors.add(0, first)
strategy = ColorfulStrategy(colors, true)
}
}
fun check(speed: Double, acc: Double, total: Int) {
if (!isEnable) {
return
}
if (sorted.isEmpty()) {
return
}
if (acc < 0) {
hasLessThan0 = true
}
val delta = (total * 0.35).toInt()
val last = total - delta
val entry = sorted.floorEntry(acc)
if (entry != null) {
if (index >= last - 1) {
if (startColor == Int.MAX_VALUE) {
startColor = entry.value
if (endEvaluator == null) {
endEvaluator = ArgbEvaluator()
}
colors += entry.value
} else {
if (endEvaluator != null) {
val fraction = (index - last) * 1.0f / delta
colors += endEvaluator!!.evaluate(
fraction,
startColor,
COLOR_TRANSPARENT
) as Int
}
}
} else {
colors += entry.value
}
}
index++
}
fun remove(acc: Double): List<Int> {
if (!isEnable) {
return emptyList()
}
if (sorted.isEmpty()) {
throw AssertionError("sorted map must not be null.")
}
val entry = sorted.floorEntry(acc)
if (entry != null) {
colors.remove(entry.value)
}
return ArrayList(colors)
}
private fun fill() {
var startValue = -4.0
var endValue = 0.0
val step = 0.01
var current = startValue
val evaluator = ArgbEvaluator()
val interceptor = AccelerateInterpolator()
var total = endValue - startValue
while (current <= endValue) {
val fraction = interceptor.getInterpolation(((current - startValue) / total).toFloat())
val colorValue = evaluator.evaluate(fraction, COLOR_RED_DARK, COLOR_BLUE) as Int
sorted[current] = colorValue
current += step
}
startValue = 0.01
endValue = 3.0
current = startValue
total = endValue - startValue
while (current <= endValue) {
val fraction = (current - startValue) / total
val colorValue =
evaluator.evaluate(fraction.toFloat(), COLOR_BLUE, COLOR_BLUE_DARK) as Int
sorted[current] = colorValue
current += step
}
}
fun getStrategy(): Strategy = if (isEnable) {
(strategy ?: DefaultStrategy())
} else DefaultStrategy()
}