From 712bf3fc276aacc80f501ac8855b804c3a9ebab7 Mon Sep 17 00:00:00 2001
From: Rishav-N <rishav.a.nair@gmail.com>
Date: Sun, 26 Apr 2026 23:22:10 +0000
Subject: [PATCH] Added rover path and test new object detection stream

---
 .../__pycache__/ros_bridge.cpython-310.pyc    | Bin 3978 -> 6625 bytes
 umdloop_gui_web/app/GUI functions/MapView.js  | 148 +++++++++++++++++-
 umdloop_gui_web/ros_bridge.py                 | 117 +++++++++++++-
 umdloop_gui_web/server.py                     | 124 ++++++---------
 4 files changed, 303 insertions(+), 86 deletions(-)

diff --git a/umdloop_gui_web/__pycache__/ros_bridge.cpython-310.pyc b/umdloop_gui_web/__pycache__/ros_bridge.cpython-310.pyc
index 38fc5145d1ce5cae9c46a5eba6fa46c429eaa65d..fc82c4067c02ee87db9d611ce1c3017879f2082b 100644
GIT binary patch
literal 6625
zcmZu#TaO&ab?$rj^jvm!xg?h&EsrQE)Yu6(QZ7OqNg+*<0&RLpbJtcfR?z94>YeRj
z&-AdWXSp-zg@Y^sIS&jCII)u`4wgUwgNC2{>>pwHv0j59@I#C|1PEYTlD|_uSBl-}
z>Qhyx?&o~xoJy-zU&Hgy_kR_C<rPi)Ps%Jl7BW}xiJu^08q*W4Rs8jquJT69z~4yB
zp4GB+sxuS2=d>I}TZ!BAT3)ZzD)s!9ugdJC+^e)IiguD}uhyz5+D%q^^;TWcUb5O-
zYpwN8wN9ygDOvBGZk^V(_cZ3S@<WZ4BkR~~ok70Bs>oN5jn>)d?6KC`VEVS!to;%*
z*0!3uw6;<f;a|Dh&f>IxEs3Lk)-<L6^>q6VPxs;^lJ$3oJlu_wI2+wblej&St9PR$
zUMfNt&UVJ*eg{-_D?ErhVHWMA@7>v^QSOA<e$$X8RBVUYjrdTmTuXZc9tjb#o4v3@
zbEv-?Ws#c38}DA_JRG%YmWz)$$%q3Gkw&}RGCtJybfz=oq1Q5*8CiP<vzYzRYT3v+
z$T`eK&PC2c&SNFyO33-h(SBL2GCRYntoBfERoF^YMR}dAqP)h=vUPSE<tra*me#6c
z?>1!RZYtgzh+?nW`oaVq(Dczf#TnFO+Oc+m**($eq;f5QJRmhQE7vlc8OJ7aPKLQL
z>ydt>XI{6I>w%w@yA}Maxpq>^R+ydZPl&TV<21mrnj4B^Ejz`WT<fmq#uG@{jK@T8
zr*m`Cn>pb<!(8y5%}vF-adPen&FBR+uk#(EFE9`3=Vtv_YAkEg{zX<o`_Jdr(pa|Q
zu_rtY=7Z;@+$J8Z;o=kR<YiVab^&`>*^+05J(i^DAm|L^fTtqZ<uU6-<N9WQB0NEs
z2AzTUC2cUI!)DPS+aH&xKIlPe$KEEYH}~ShvAsD+!agU?@rBKH*o%0$8IxEAJbbX(
zo{1W|AEimU$)=Jf#v6;L*@*jb7KceZj#%>*X^Y_?;?fHODh~o#<LN=fgF!05miDEk
z#--!t9unyWZKXk+uz}lDw6b&e>elwn>svd)t=reG-jY6>sS_t*k>1_ww{Bkj@~!K#
z%;$O~>unxEhl0UyH;Ki5#JNk{)nK{-R3pn@zP`N^T)%PS_T3$MYSKgucSW1W1DYcz
z5JM~MRnQKTWH)TzlioLP-@3YU^VW4<qS{(O>zG%UvVDxrpv|&$E$y>nv87;-V{3!<
zfvf}xrY5qWJBT`RZJL{JtMn(#BD&AZG{#C$9LRJIyh5ex!Mx3Ue7_TAL6UYl*nBJQ
z@1;#gS|UpJq<KFT(xtT!;i+k>A{@FZa?u|VPjy)ea2lZyLGV=j_0`S&v=?o1>|}V*
zpZtRdVsk+b7wO<Zw7WT%%gciiU&Dk?;S&jxitd<>X_$siuk*3*db+1uOL<GxQEL6x
z_f-92iSOw2`Ucu9mZPV|{F*yHy(puXXVPf)M5k?FGSi1>62@!z#2+Hb^)7H{sPlDD
zKub_(s7&Sbe>0%xK%{N(6kpTW0!({2+&CMuNS2bc-%(`K<bR3|`J0r`E;J4PMWX+N
zl0TXye@xViNd5+&AlX~jEyL0)pLm~+UsztpqDU^Sql#vvJZc@k06}x+Kqa*Xjr%lT
zDr5RNt!s46u61NA<?SQjCAf`q+7Yl8lnKhtoD&zH2lN6aA2}WE$fb7gYJdIek(YZ#
zU%9cN9hD|IJ2#Q@b1V0mbzVEG9hGxCFEJ~3)-{!{<nBo+ujJ*9K?ryM^&AKr00B?R
zz`Y8yvuf@h>mO;%`Jp+(KzB>w)qGbwSf@5<{N~Dd{chBb;)94a6s|QM#Myph>@)y7
zk!aSWtq64rKp+%C5vGWwA4+{BtsV@nG~1*s9Eu$Fg>=HfAnG%|j$wF{k}n{UW)k(A
z)%jUUFYLGXQyv`7sFCz1We|)x4g7O40x7@r)mf$~XM+D3b!)Igd?R#^S`%XQtc*0k
zMN1Y$)FJV8yRQ3qK^wka!&?De*B#?UeSCgda+cs~Npwj335u2I?10FWupjFX5Qxg-
z4HzU6dx(dnbuFg9sTo>8B4V7_Pc&V7AIf0iJvPZ?Z)>k>;^hZ8R(k&mAC*B(_zL<4
zEZMsw0HL&4n1%dhlySI<8vi{c((k8Pyf+Gfx=^3FwtS5^o>7@gDEm8nf?&}HlsIYw
zE`B_|u)OqT6kS?70Tki6TKj9Th7fP177*_t6vFK4PzI}OKoQK`X8N(gFXVRD>e?!G
z4CBZ-a{DfFR5Hn<g$w1dy53PKE9Fk^G2^_pp<z#b<XtGkG+&<ApQZZByk6z2%si?w
z>u3dY@p(!qv!R&vten^3#MF<?qgBwW%vGt!%wxQRJ!+R#R2ftcWjgvWPO7<|m!W#q
zyq2%*IZFL(oMr7XTxfO9E6+L4N1r)Qe~W(!8~5M%=(!?iq^7h~`un3nn(ap-hSe#o
zO3b8z&lc^JN6k9y`pl`2*6wb4D4jN(X_zo~KNMk>aWw}2a}2=WLLwajKLdJJ{Glsx
zKZCwTVwhxP<)VyQNqa9z!;D{{c1prt1=U=e3lxMfJ%kXNm;ryE*!~iUG}=%>c<YA1
zU*LcEx->@k4&T844QVIgZj|tE5U;%#a{)!gGM|;q*HHiW_>@7hprD1(TGwj^QKX{u
z63D}tL1{OT+b}$swTqvQUs{&l`5w)z{bbYs_b=KeMwvcDlOEGw&~m;5n11|uUH!ZI
zhuVia+;rvk=LRz$8LGwr7o2OP_OZTaz7O4=YqQejS3h(1)>a$cFFj;Om8B>9MFW3F
zyJte}b%abxwbdRyRhAM?5cxPtyOmCp1(e=fN!Z(E;X6M@PEdcoHvWU9y?7A9rQ8G1
zDzEDDTS*GnNW250XbGR!&Ej5^4zs4C4qkfGHpL_eX`}_`Fyl%jCK!{VnBS*F&8JV4
znpADtycqIFs1P+I1U40TAkHUi)+@hx25Xnwz_P&gUP2u@p_#FM0~rc>2zL;k=n7X&
z1SUXG7(@#O5xA3+F*Fv8p}93aduQV3!s<;u+{W9DOTX4HVfill<q9{?gOcvVDW2Q0
zDZmbi@i{(;tWTQE+~=QyQ;>*}6j$^YjPd7|&gWTv{&nz9gmvpmo0dF%NK9r%=NHIe
zsT!7w$gfyxZeYOx;E%K)Dv+XW=_2N1_9I=KW6rjgS!905L&^1HJ+}k+DY>C24-^0o
zWfXZCCw^{|@1kNvEk|^VUSO<p=cM{X6IYlA-^e+sp*J^oyDQ=*E1|?asiVZ3v;v$@
zT6wC~x0nwek6LwWM<rIyR`XJK4WpL2r}jwpD_i3;+wdO{6f_XkH#%vUe5nEJ{`T1U
z{RRxY`e$kKHouJ>fb^Cp(hL1)H_aP2#$S9Uv}=Sa+HZ)6BdTh^S~kLiFa|6oQK#73
z^((67sT(MUKa{0l?lU#Gs;It)X*77$#l-<aHgo63_`(j9hBcrz4U%1&FSHCi1gksE
z^|{RO(-=gq%p|;+M-j<c)G-ghF!#{p+SJWLY?>g(?6)JiLK6yTH-b=%`fX|Rb}|^r
z7sMd$2g80AC&At@8*&6rh(i+?33v->Kax%{CAeAbHe%a|$vVY7Md_q7Yd1|3>53s(
z1Z+YNDczR%1>k&z=J!=vg^3yQF;N!HMV8gHih*TWO>aN!GhF9XCj%69oScqlAYYy-
z)`TcaHQWU>-NQcq46K4Im#4$2|FmXVx(8Q{-ild-EEEcP4wXBw2i`NKzOiPEUtZF(
z=Z^%K?O`0m7^HN3MD!}f;e84~14Nf}1u#sAt^~pTVVD#(Do9fyuL?p`c*`5qN12jK
zl#qwT$*S=Ti8KM9{E)JbC|jLGjqNB&f?#21UMCj9QC>wtzLucGLnv7LTFtGUuett<
zwep&;>Yr;<u23UF?djc>GGH3rTQTdQ)`Ctl2Y;Kn&^S-}*eb-|S#+2!-80ce2icTs
z)L#RMy1gk<!W=|(nMq&^$|i^Psj+o~V(31=TRKH_52=F73bErap$BQ*!XZl=VR!r9
zQ+>gn&5WAb+h5U;Q`96Mb$n_*$ysRnnc2?V(x0O}P)vLLEiwpQou4L5V>%+!(<O4g
z^_laHo62#eSchn2W*3Ho8INE{-q-piOUs<m7p87`Uw=ToQ9n4N%sr-+lf&;(iFk*o
zlM>MJcIJ1>=&M59xHqJGH@aD)*is=O9DK^_S&hMkP~pJRj1UflOD+W6r#j;g{Kn+j
z4)-F$DZ1xq^Z+?AbiP4QC@#;K?(paUzM*Ka6jm>4D9E@>mrSoU8*Luqx@Un~UDSrW
zBX)2z>)_A;6Z|7OG>3&zFYS-l?%v*R6gOy%$*DG1_`iUK|A3NzqU77u!btDYl}eo9
z8k4}O7hUH(<w|Dx_ld)c1tJ!NpM_jFJL)b7_b<RRc)KJsh(K}GoAH08Zk2q@h2%d_
z_J8=qWh9<mHw?Z0vEg_yvDV+>GmKAs8vp`mAcxV=y^np{0gPPyuW@}rl+-|<k)xTF
z{Q$k=%(TZZ6>_BRHdaxhpBNOzDUHwz>EY+_hjm3M>4x*1kl@nNnL=auKVpEUTkIii
zpR6!kc=2=;kP@lQ<o{0Pp4cB|EPc=~w)%N{@+0ukb+D*|@NnZpPBb~lo^kR2mlSB)
z*A{%9e*iOoOv!gCA+X`JyPUdP*!KC}e-9P^gHI`_hmky|a*<PM^BjMhT9K+3g5Vc2
zrxrt4A}d8fVUsy|b+S|x;W}-8p;_EnRz$`ETtA7+NQ#TevdT`H(>ckC^5dpV1Odug
z3i!OUrsO(JE(i}|f&0pNmBMMlTD1aPj^eJNU7+FfRu7-MunF&Ar!_%$P-=_yicx{R
RqLeNa@R{1TYajS;{th`6ZT<iN

delta 1431
zcmZuxOK%)S5bmDW&g{;<{Q?pZ8Jw`fIFVu$q@WNUi3NlN+XT=kQfsn3UXMLHvvjwe
z5EdC^OBf_1tT`g2wQ}OZC7d|$C%83Sa?0PJYBsVg%OmyIRn^~Ae_hoxPcQ%UaxJS?
z%LJas|2&Hi+6T2WJNw{q!f8T+@k|2>zL6MxGcYN}%*5*3fnC^E;`B>FsqY4E-wV7V
zW+&x-C8!j(llc8=P%Z3IQtQ`)IweblyWHC&+>6XzGiZQc<`wWOyLBUIM$KIkv^ZTQ
z9sl6JY|gtKZm)*wX8f>=T8}^Gb4R|H|3=U6IFYkv@Dg|Ttf0iJyu$rG8n{0Yiv%8|
zt7(5FlS>2neiBEi>e6GmFqH!XXZam~BD-WnIX$GPen^<1%pp-0H+ErWwsN@1t)J<)
zRFyW|A!XjDs=QGF!yl4SRn@pXq=!hYA5jfpG=@gOXsQ->hGe5XG!88a8;m9n$!L<7
z#v6iMH@|1zxjJ)P^0_#TRU9VqqlkB=v@N#=k<cz<7-vk^M7A9XHpnE<vivn`<auxw
zU1hyNKCsU=O>N02S<~iMnbf7;K<0nhU)1ZsX~2+|0DPLyI`jFy^W()iaK(89T<sX*
zEZVOk%pSojXuSyVW`4c2kWbc!%i7|h3dJ-8b!o75KZ)hKcnNuD06OM4&jk#el1w+A
zzrxaRoAomuy^}w!Uv!=UpO7c5#s%v23Y(DY`L*V+Zylu;O^ECIgAl5*mI)>!0re0r
zMy;hROtih0WT6t{ljZf+FOzsCZ6=`t$Wm>pED;O&pRLRDS77DDLG_f3QV!LWtOx1X
z{Uqyd#%b@vyxrcY8e$$_c>|zR&JWsi0ajLE3yKP9Qz{`|NB08&XbbBmp_JVyNf<k}
z)j6aTg~jg^lSnjNXijaeR&JF=Ilnsb$D;Psx`;v!3bb_#q-dL=qTlJb#3#ChiN1L<
zJ-JWmYCf8p-C2f!xQ%cNVG%$Z*`~JeKEc<rm8!TO-4G%Z0tJXqkm1IX!5xIk-a*&-
ztk3{AYY?Y!C!zC7+XE4&O03{ZCsf>n*!M8xLjLab-zy)3*(r%a3aZdPkDyH1*DQtB
z7n;Q97<c9Rmg3oibgcNa)C_o!NxnRD>Fy0M#Z81IgrX6+vp~)<Nrkwg)E~jZBN!5|
zi%VSUI{vJ{Xs2DAR4nHI&h+xTFEqa_T3S>D*L6i?l6A9GMGw_!xwZQ?+~chzx`zK8
WIfWY-F7*wcP88_VhFRMzU-=*8H$wdY

diff --git a/umdloop_gui_web/app/GUI functions/MapView.js b/umdloop_gui_web/app/GUI functions/MapView.js
index cfd5642..3545726 100644
--- a/umdloop_gui_web/app/GUI functions/MapView.js	
+++ b/umdloop_gui_web/app/GUI functions/MapView.js	
@@ -1,10 +1,29 @@
 "use client";
 
-import React, { useState, useRef, useCallback, useEffect } from "react";
-import { Map, Marker } from "react-map-gl/maplibre";
+import React, { useState, useRef, useCallback, useEffect, useMemo } from "react";
+import { Map, Marker, Source, Layer } from "react-map-gl/maplibre";
 import "maplibre-gl/dist/maplibre-gl.css";
 import { useLocalTiles } from "../config";
 
+const PLAN_LINE_LAYER = {
+  id: "global-plan-line",
+  type: "line",
+  paint: {
+    "line-color": "#3b82f6",
+    "line-width": 3,
+    "line-dasharray": [4, 2],
+  },
+};
+
+const DRIVEN_PATH_LAYER = {
+  id: "driven-path-line",
+  type: "line",
+  paint: {
+    "line-color": "#f59e0b",
+    "line-width": 2,
+  },
+};
+
 export default function MapView({ selectedSubsystem, titleOverride }) {
   const [viewState, setViewState] = useState({
     longitude: -76.9378,
@@ -15,9 +34,18 @@ export default function MapView({ selectedSubsystem, titleOverride }) {
   const [roverPosition, setRoverPosition] = useState(null);
   const [rosStatus, setRosStatus] = useState("no fix");
   const [followRover, setFollowRover] = useState(false);
+
+  // Global plan: raw coords held in a ref; planVersion bumps only when plan actually changes
+  const globalPlanRef = useRef(null);
+  const [planVersion, setPlanVersion] = useState(0);
+
+  // Driven path history — [[lon, lat], ...]
+  const [drivenPath, setDrivenPath] = useState([]);
+  const lastDrivenPoint = useRef(null);
+
   const mapRef = useRef();
 
-  // Poll Flask backend for latest /gps/fix data (sourced from ROS via ros_bridge.py)
+  // Poll Flask backend for latest /gps/fix and accumulate driven path
   useEffect(() => {
     const poll = async () => {
       try {
@@ -27,7 +55,18 @@ export default function MapView({ selectedSubsystem, titleOverride }) {
           const pos = { latitude: data.latitude, longitude: data.longitude };
           setRoverPosition(pos);
           setRosStatus("fix");
-          // Keep map centered on rover when follow mode is active
+
+          // Accumulate driven path; only append if moved more than ~0.5 m
+          const lon = data.longitude;
+          const lat = data.latitude;
+          const last = lastDrivenPoint.current;
+          const MIN_DELTA = 0.000005; // ~0.5 m in degrees
+          if (!last || Math.abs(lon - last[0]) > MIN_DELTA || Math.abs(lat - last[1]) > MIN_DELTA) {
+            const point = [lon, lat];
+            lastDrivenPoint.current = point;
+            setDrivenPath((prev) => [...prev, point]);
+          }
+
           setFollowRover((prev) => {
             if (prev) {
               setViewState((vs) => ({ ...vs, latitude: pos.latitude, longitude: pos.longitude }));
@@ -47,6 +86,53 @@ export default function MapView({ selectedSubsystem, titleOverride }) {
     return () => clearInterval(id);
   }, []);
 
+  // Poll Flask backend for latest /plan (global plan from Nav2).
+  // Only bump planVersion (triggering re-render) when the plan actually changes.
+  useEffect(() => {
+    const fetchPlan = async () => {
+      try {
+        const res = await fetch("http://127.0.0.1:5000/navigation/plan");
+        const data = await res.json();
+        if (data.available && data.coordinates?.length >= 2) {
+          const coords = data.coordinates;
+          const prev = globalPlanRef.current;
+          const changed =
+            !prev ||
+            prev.length !== coords.length ||
+            prev[0][0] !== coords[0][0] ||
+            prev[0][1] !== coords[0][1];
+          if (changed) {
+            globalPlanRef.current = coords;
+            setPlanVersion((v) => v + 1);
+          }
+        }
+      } catch {
+        // silently ignore; plan display is optional
+      }
+    };
+
+    fetchPlan();
+    const id = setInterval(fetchPlan, 2000);
+    return () => clearInterval(id);
+  }, []);
+
+  // Stable GeoJSON objects — only recreated when underlying data actually changes
+  const planGeoJSON = useMemo(
+    () =>
+      globalPlanRef.current?.length >= 2
+        ? { type: "Feature", geometry: { type: "LineString", coordinates: globalPlanRef.current } }
+        : null,
+    [planVersion]
+  );
+
+  const drivenGeoJSON = useMemo(
+    () =>
+      drivenPath.length >= 2
+        ? { type: "Feature", geometry: { type: "LineString", coordinates: drivenPath } }
+        : null,
+    [drivenPath]
+  );
+
   // Snap to rover and enable follow mode
   const centerOnRover = () => {
     if (!roverPosition) return;
@@ -80,6 +166,11 @@ export default function MapView({ selectedSubsystem, titleOverride }) {
 
   const deleteAllWaypoints = () => setWaypoints([]);
 
+  const clearDrivenPath = () => {
+    setDrivenPath([]);
+    lastDrivenPoint.current = null;
+  };
+
   const MAPTILER_KEY = "DDQqKsPBfdOZOVxgcoy5";
   const tileUrl = useLocalTiles()
     ? "/tiles/{z}/{x}/{y}.jpg"
@@ -143,8 +234,41 @@ export default function MapView({ selectedSubsystem, titleOverride }) {
           {followRover ? "Following Rover" : "Center on Rover"}
         </button>
 
-        {/* Waypoint controls */}
+        {/* Legend */}
+        <div style={{ display: "flex", alignItems: "center", gap: "14px", fontSize: "12px", opacity: 0.8 }}>
+          {planGeoJSON && (
+            <span style={{ display: "flex", alignItems: "center", gap: "5px" }}>
+              <span style={{ display: "inline-block", width: 20, height: 3, background: "#3b82f6", borderTop: "2px dashed #3b82f6" }} />
+              Global Plan
+            </span>
+          )}
+          {drivenPath.length >= 2 && (
+            <span style={{ display: "flex", alignItems: "center", gap: "5px" }}>
+              <span style={{ display: "inline-block", width: 20, height: 3, background: "#f59e0b" }} />
+              Driven Path
+            </span>
+          )}
+        </div>
+
+        {/* Controls */}
         <div style={{ display: "flex", alignItems: "center", gap: "12px", marginLeft: "auto" }}>
+          {drivenPath.length >= 2 && (
+            <button
+              onClick={clearDrivenPath}
+              style={{
+                padding: "6px 14px",
+                cursor: "pointer",
+                background: "#4b5563",
+                color: "white",
+                border: "none",
+                borderRadius: "6px",
+                fontWeight: 700,
+                fontSize: "13px",
+              }}
+            >
+              Clear Path
+            </button>
+          )}
           <span style={{ fontSize: "13px" }}>Waypoints: {waypoints.length}</span>
           {waypoints.length > 0 && (
             <button
@@ -200,6 +324,20 @@ export default function MapView({ selectedSubsystem, titleOverride }) {
           mapStyle={mapStyle}
           attributionControl={true}
         >
+          {/* Global plan from Nav2 /plan topic */}
+          {planGeoJSON && (
+            <Source id="global-plan" type="geojson" data={planGeoJSON}>
+              <Layer {...PLAN_LINE_LAYER} />
+            </Source>
+          )}
+
+          {/* Driven path accumulated from /gps/fix */}
+          {drivenGeoJSON && (
+            <Source id="driven-path" type="geojson" data={drivenGeoJSON}>
+              <Layer {...DRIVEN_PATH_LAYER} />
+            </Source>
+          )}
+
           {roverPosition && (
             <Marker
               longitude={roverPosition.longitude}
diff --git a/umdloop_gui_web/ros_bridge.py b/umdloop_gui_web/ros_bridge.py
index a938af8..d2b4b19 100644
--- a/umdloop_gui_web/ros_bridge.py
+++ b/umdloop_gui_web/ros_bridge.py
@@ -1,5 +1,6 @@
 # ros_bridge.py
 
+import math
 import threading
 import rclpy
 
@@ -9,7 +10,9 @@
 
 from std_msgs.msg import String
 from msgs.action import NavigateToGPS
-from sensor_msgs.msg import NavSatFix
+from nav_msgs.msg import Path
+from sensor_msgs.msg import NavSatFix, CompressedImage
+from vision_msgs.msg import Detection2DArray
 
 
 class RosGpsClient(Node):
@@ -19,6 +22,9 @@ def __init__(self):
         # Latest rover GPS fix (None until first message arrives)
         self.rover_position = None
 
+        # Global plan as [[lon, lat], ...] in GPS coords (None until first /plan arrives)
+        self.plan = None
+
         # Action client (GNSS navigation)
         self._client = ActionClient(
             self,
@@ -48,6 +54,43 @@ def __init__(self):
             gps_qos,
         )
 
+        # Global plan subscriber — Nav2 planner publishes with VOLATILE durability
+        plan_qos = QoSProfile(depth=1)
+        plan_qos.durability = DurabilityPolicy.VOLATILE
+        plan_qos.reliability = ReliabilityPolicy.RELIABLE
+        self.create_subscription(
+            Path,
+            "/plan",
+            self._plan_callback,
+            plan_qos,
+        )
+
+        # Object detection: latest compressed JPEG + bounding boxes.
+        # The streaming endpoint reads these without decoding here, so the
+        # callback path stays cheap (one bytes() copy per frame).
+        self._frame_cv = threading.Condition()
+        self._latest_jpeg = None
+        self._latest_detections = []
+        self._frame_seq = 0
+
+        cam_qos = QoSProfile(depth=1)
+        cam_qos.reliability = ReliabilityPolicy.BEST_EFFORT
+        self.create_subscription(
+            CompressedImage,
+            "/camera/image_raw/compressed",
+            self._image_callback,
+            cam_qos,
+        )
+
+        det_qos = QoSProfile(depth=1)
+        det_qos.reliability = ReliabilityPolicy.BEST_EFFORT
+        self.create_subscription(
+            Detection2DArray,
+            "/yolo/detections",
+            self._detections_callback,
+            det_qos,
+        )
+
         self.get_logger().info("RosGpsClient initialized")
 
     def _gps_callback(self, msg: NavSatFix):
@@ -57,6 +100,78 @@ def _gps_callback(self, msg: NavSatFix):
                 "longitude": msg.longitude,
             }
 
+    def _plan_callback(self, msg: Path):
+        if not msg.poses or self.rover_position is None:
+            return
+
+        # Use the first pose (rover's current map position) as the local origin.
+        # Distances from that origin are converted to GPS offsets using a flat-earth
+        # approximation — accurate to <1 m over competition-scale distances (<500 m).
+        anchor_x = msg.poses[0].pose.position.x
+        anchor_y = msg.poses[0].pose.position.y
+        anchor_lat = self.rover_position["latitude"]
+        anchor_lon = self.rover_position["longitude"]
+        cos_lat = math.cos(math.radians(anchor_lat))
+
+        gps_coords = []
+        for pose in msg.poses:
+            dx = pose.pose.position.x - anchor_x
+            dy = pose.pose.position.y - anchor_y
+            lat = anchor_lat + dy / 111111.0
+            lon = anchor_lon + dx / (111111.0 * cos_lat)
+            gps_coords.append([lon, lat])
+
+        self.plan = gps_coords
+        self.get_logger().info(f"Received /plan with {len(gps_coords)} poses")
+
+    # --------------------------------------------------
+    # Object detection stream callbacks
+    # --------------------------------------------------
+    def _image_callback(self, msg: CompressedImage):
+        data = bytes(msg.data)
+        with self._frame_cv:
+            self._latest_jpeg = data
+            self._frame_seq += 1
+            self._frame_cv.notify_all()
+
+    def _detections_callback(self, msg: Detection2DArray):
+        boxes = []
+        for det in msg.detections:
+            bbox = det.bbox
+            center = bbox.center
+            # vision_msgs >= Iron uses center.position.x/.y; older uses center.x/.y
+            if hasattr(center, "position"):
+                cx, cy = center.position.x, center.position.y
+            else:
+                cx, cy = center.x, center.y
+            sx = bbox.size_x
+            sy = bbox.size_y
+            x1 = int(cx - sx / 2.0)
+            y1 = int(cy - sy / 2.0)
+            x2 = int(cx + sx / 2.0)
+            y2 = int(cy + sy / 2.0)
+
+            label = ""
+            score = 0.0
+            if det.results:
+                first = det.results[0]
+                hyp = getattr(first, "hypothesis", first)
+                label = getattr(hyp, "class_id", getattr(hyp, "id", "")) or ""
+                score = float(getattr(hyp, "score", 0.0))
+
+            boxes.append((x1, y1, x2, y2, label, score))
+
+        with self._frame_cv:
+            self._latest_detections = boxes
+
+    def wait_for_frame(self, last_seq, timeout=1.0):
+        with self._frame_cv:
+            self._frame_cv.wait_for(
+                lambda: self._frame_seq != last_seq,
+                timeout=timeout,
+            )
+            return self._frame_seq, self._latest_jpeg, list(self._latest_detections)
+
     # --------------------------------------------------
     # Publish navigation mode
     # --------------------------------------------------
diff --git a/umdloop_gui_web/server.py b/umdloop_gui_web/server.py
index e2fb016..80c2738 100644
--- a/umdloop_gui_web/server.py
+++ b/umdloop_gui_web/server.py
@@ -2,24 +2,20 @@
 import json
 import os
 import re
-import signal
 import ssl
-import subprocess
-import sys
 import time
 from urllib import error as urllib_error
 from urllib import request as urllib_request
 
 import cv2
+import numpy as np
 from flask import Flask, Response, jsonify, request
 from flask_cors import CORS
-from ultralytics import YOLO
 from ros_bridge import ros_context
 
 
 app = Flask(__name__)
 CORS(app)
-process = None
 
 MIKROTIK_HOST = os.getenv("MIKROTIK_HOST", "").strip()
 MIKROTIK_USER = os.getenv("MIKROTIK_USER", "").strip()
@@ -202,100 +198,59 @@ def video_feed(cam_id):
                     mimetype='multipart/x-mixed-replace; boundary=frame')
 
 
-MODEL_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "umdloop_gui_native", "best.pt"))
-model = YOLO(MODEL_PATH)
+def annotated_stream():
+    ros_context.start()
+    node = ros_context.node
 
-def annotated_stream(camera_index=0):
-    cap = cv2.VideoCapture(camera_index)
+    last_seq = -1
     while True:
-        ok, frame = cap.read()
-        if not ok:
-            break
+        seq, jpeg_bytes, detections = node.wait_for_frame(last_seq, timeout=1.0)
+        if jpeg_bytes is None or seq == last_seq:
+            continue
+        last_seq = seq
 
-        results = model(frame, verbose=False)
+        # No detections → pass the JPEG through unchanged (no decode/encode).
+        if not detections:
+            yield (b"--frame\r\n"
+                   b"Content-Type: image/jpeg\r\n\r\n" + jpeg_bytes + b"\r\n")
+            continue
 
-        # draw boxes on frame
-        for r in results:
-            for box in r.boxes:
-                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
-                x1, y1, x2, y2 = map(int, [x1, y1, x2, y2])
-                cls_id = int(box.cls[0])
-                conf = float(box.conf[0])
-                name = model.names.get(cls_id, str(cls_id))
+        np_arr = np.frombuffer(jpeg_bytes, dtype=np.uint8)
+        frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+        if frame is None:
+            yield (b"--frame\r\n"
+                   b"Content-Type: image/jpeg\r\n\r\n" + jpeg_bytes + b"\r\n")
+            continue
 
-                cv2.rectangle(frame, (x1, y1), (x2, y2), (0,255,0), 2)
-                cv2.putText(frame, f"{name} {conf:.2f}", (x1, max(y1-10, 0)),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
+        for x1, y1, x2, y2, label, score in detections:
+            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            text = f"{label} {score:.2f}" if label else f"{score:.2f}"
+            cv2.putText(frame, text, (x1, max(y1 - 8, 0)),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
 
-        # encode frame to jpg
-        ok, buffer = cv2.imencode(".jpg", frame)
+        ok, buffer = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 80])
         if not ok:
             continue
-
         yield (b"--frame\r\n"
                b"Content-Type: image/jpeg\r\n\r\n" + buffer.tobytes() + b"\r\n")
 
-    cap.release()
-
 @app.get("/object-detection/stream/0")
-def object_detection_stream(cam_id=0):
+def object_detection_stream():
     return Response(
-        annotated_stream(cam_id),
+        annotated_stream(),
         mimetype="multipart/x-mixed-replace; boundary=frame"
     )
 
 @app.post("/object-detection/start")
 def start_detection():
-    global process
-    if process is not None and process.poll() is None:
-        return jsonify({"ok": True, "status": "already_running"}), 200
-
-    
-    script_path = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "..", "umdloop_gui_native", "yolo_live_logger.py")
-    )
-
-    if not os.path.exists(script_path):
-        return jsonify({"ok": False, "error": f"Script not found: {script_path}"}), 500
-
-    
-    process = subprocess.Popen(
-        [sys.executable, script_path],
-        cwd=os.path.dirname(script_path),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True
-    )
-
-    return jsonify({"ok": True, "status": "started", "pid": process.pid}), 200
+    try:
+        ros_context.start()
+    except Exception as exc:
+        return jsonify({"ok": False, "error": str(exc)}), 500
+    return jsonify({"ok": True, "status": "started"}), 200
 
 @app.post("/object-detection/stop")
 def stop_detection():
-    global process
-    if process is None or process.poll() is not None:
-        process = None
-        return jsonify({"ok": True, "status": "not_running"}), 200
-
-    # Try graceful stop 
-    try:
-        process.terminate()  
-        process.wait(timeout=3)
-    except Exception:
-        pass
-
-    #If still alive, force kill the whole tree (Windows guaranteed)
-    if process.poll() is None:
-        try:
-            subprocess.run(
-                ["taskkill", "/F", "/T", "/PID", str(process.pid)],
-                check=False,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-        except Exception:
-            pass
-
-    process = None
     return jsonify({"ok": True, "status": "stopped"}), 200
 
 
@@ -307,8 +262,8 @@ def radio_status():
 
 @app.get("/object-detection/status")
 def status():
-    global process
-    running = process is not None and process.poll() is None
+    node = ros_context.node
+    running = node is not None and node._latest_jpeg is not None
     return jsonify({"ok": True, "running": running}), 200
 
 @app.get("/navigation/rover-position")
@@ -320,6 +275,15 @@ def rover_position():
     return jsonify({"ok": True, "fix": True, "latitude": pos["latitude"], "longitude": pos["longitude"]}), 200
 
 
+@app.get("/navigation/plan")
+def get_plan():
+    ros_context.start()
+    plan = ros_context.node.plan
+    if plan is None:
+        return jsonify({"ok": True, "available": False}), 200
+    return jsonify({"ok": True, "available": True, "coordinates": plan}), 200
+
+
 @app.post("/navigation/path-plan")
 def navigation_path_plan():
     data = request.get_json(silent=True) or {}