583 lines
20 KiB
Dart
583 lines
20 KiB
Dart
import 'dart:async';
|
||
import 'dart:math' as math;
|
||
|
||
import 'package:flutter/services.dart';
|
||
import 'package:get/get.dart';
|
||
import 'package:shared_preferences/shared_preferences.dart';
|
||
import 'package:terepi_seged/controls/geoid_grid.dart';
|
||
import 'package:terepi_seged/services/app_database.dart';
|
||
import 'package:terepi_seged/services/coord_converter_service.dart';
|
||
import 'package:terepi_seged/services/gnss/gnss_service.dart';
|
||
import 'package:terepi_seged/services/project_service.dart';
|
||
import 'package:wakelock_plus/wakelock_plus.dart';
|
||
|
||
import '../../models/stakeout_point.dart';
|
||
|
||
/// Kitűzési sorrend.
|
||
enum StakeoutOrder { idAsc, idDesc, nearest }
|
||
|
||
/// Eltérés-kijelzési mód a közeli fázisban.
|
||
enum DeviationMode {
|
||
line('Inline / crossline'),
|
||
travel('Haladási irány'),
|
||
northEast('Észak / kelet');
|
||
|
||
final String label;
|
||
const DeviationMode(this.label);
|
||
}
|
||
|
||
/// A kitűzés "agya": célpont-kezelés, sorrend, vonal-geometria,
|
||
/// eltérés-számítás, tárolás, haptikus visszajelzés.
|
||
///
|
||
/// Az egyetlen térképnézetbe illeszkedik: a MapSurveyController a
|
||
/// setMode()-ban hívja a [setActive]-ot (mode == MapSurveyMode.stakeout),
|
||
/// a service pedig csak aktív állapotban dolgozik (haptika, fázis).
|
||
/// Minden adatbázisművelet az AppDatabase-en keresztül megy.
|
||
///
|
||
/// Geometria: minden számítás EOV-SÍKBAN, méterben. A crossline irány a
|
||
/// szomszédos állomások szakaszaiból SZÁMÍTÓDIK — a vonal első pontjánál
|
||
/// az első szakasz hátrafelé, az utolsónál az utolsó szakasz előre
|
||
/// extrapolálásával, belső töréspontnál a két irány átlagával; virtuális
|
||
/// segédpontot nem tárolunk.
|
||
class StakeoutService extends GetxService {
|
||
static StakeoutService get to => Get.find();
|
||
|
||
AppDatabase get _db => AppDatabase.instance;
|
||
|
||
// ── Mód-aktiválás ────────────────────────────────────────────────
|
||
final active = false.obs;
|
||
|
||
/// A MapSurveyController hívja módváltáskor.
|
||
Future<void> setActive(bool value) async {
|
||
if (active.value == value) return;
|
||
active.value = value;
|
||
if (value) {
|
||
WakelockPlus.enable();
|
||
await load();
|
||
_applyPhase();
|
||
_scheduleHaptic();
|
||
} else {
|
||
_hapticTimer?.cancel();
|
||
WakelockPlus.disable();
|
||
}
|
||
}
|
||
|
||
// ── Állapot ──────────────────────────────────────────────────────
|
||
final points = <StakeoutPoint>[].obs;
|
||
final target = Rxn<StakeoutPoint>();
|
||
final orderMode = StakeoutOrder.idAsc.obs;
|
||
final deviationMode = DeviationMode.line.obs;
|
||
|
||
/// Tűrés (m) — tárolásnál és a céltábla belső körénél.
|
||
final toleranceXY = 0.03.obs;
|
||
|
||
/// Közeli fázis (céltábla-nézet); automatikus 5 m alatt, kézzel
|
||
/// felülbírálható.
|
||
final nearPhase = false.obs;
|
||
static const nearPhaseDistance = 5.0;
|
||
bool? _manualPhase;
|
||
|
||
final hapticsEnabled = true.obs;
|
||
|
||
final soundEnabled = true.obs;
|
||
|
||
/// Átlagolás tároláskor
|
||
final averagingSeconds = 0.obs;
|
||
final isAveraging = false.obs;
|
||
final averagingElapsed = 0.obs;
|
||
|
||
/// Max. megengedett crossline eltolás (m; 0=nincs korlát)
|
||
final maxOffset = 0.0.obs;
|
||
|
||
late GeoidGrid geoidGrid;
|
||
|
||
// ── Aktuális pozíció (EOV) és navigációs értékek ────────────────
|
||
final hasPosition = false.obs;
|
||
final curEovY = 0.0.obs;
|
||
final curEovX = 0.0.obs;
|
||
final curAlt = 0.0.obs;
|
||
|
||
final distance = 0.0.obs;
|
||
final bearingToTarget = 0.0.obs; // fok, EOV-észak = 0, óramutató
|
||
final travelHeading = Rxn<double>(); // null = állunk
|
||
|
||
/// Eltérés az aktuális [deviationMode] szerint: előre(+)/hátra(−),
|
||
/// jobbra(+)/balra(−); dz: fel(+)/le(−).
|
||
final devForward = 0.0.obs;
|
||
final devRight = 0.0.obs;
|
||
final devDz = Rxn<double>();
|
||
final withinTolerance = false.obs;
|
||
|
||
double? _histY, _histX;
|
||
Timer? _hapticTimer;
|
||
bool _toleranceAnnounced = false;
|
||
|
||
@override
|
||
void onInit() async {
|
||
super.onInit();
|
||
await _loadSettings();
|
||
geoidGrid = await GeoidGrid.load('assets/Grids/geoid_eht2014.gtx');
|
||
|
||
if (Get.isRegistered<GnssService>()) {
|
||
ever(GnssService.to.lastGgaLine, (_) => _onPosition());
|
||
}
|
||
}
|
||
|
||
@override
|
||
void onClose() {
|
||
_hapticTimer?.cancel();
|
||
super.onClose();
|
||
}
|
||
|
||
Future<void> _loadSettings() async {
|
||
final prefs = await SharedPreferences.getInstance();
|
||
toleranceXY.value = prefs.getDouble('stakeout_tolerance') ?? 0.03;
|
||
averagingSeconds.value = prefs.getInt('stakeout_avg_seconds') ?? 0;
|
||
hapticsEnabled.value = prefs.getBool('stakeout_haptics') ?? true;
|
||
soundEnabled.value = prefs.getBool('stakeout_sound') ?? true;
|
||
maxOffset.value = prefs.getDouble('stakeout_max_offset') ?? 0;
|
||
}
|
||
|
||
Future<void> saveSettings() async {
|
||
final prefs = await SharedPreferences.getInstance();
|
||
await prefs.setDouble('stakeout_tolerance', toleranceXY.value);
|
||
await prefs.setInt('stakeout_avg_seconds', averagingSeconds.value);
|
||
await prefs.setBool('stakeout_haptics', hapticsEnabled.value);
|
||
await prefs.setBool('stakeout_sound', soundEnabled.value);
|
||
await prefs.setDouble('stakeout_max_offset', maxOffset.value);
|
||
}
|
||
|
||
// ═════════════════════════════════════════════════════════════════
|
||
// Betöltés / cél-kezelés
|
||
// ═════════════════════════════════════════════════════════════════
|
||
|
||
Future<void> load() async {
|
||
final projectId = ProjectService.to.activeProjectId;
|
||
if (projectId == null) {
|
||
points.clear();
|
||
target.value = null;
|
||
return;
|
||
}
|
||
points.value = await _db.listStakeoutPoints(projectId);
|
||
if (target.value == null ||
|
||
!points.any((p) => p.uuid == target.value!.uuid)) {
|
||
target.value = _firstPending();
|
||
}
|
||
_recompute();
|
||
}
|
||
|
||
List<String> get lines =>
|
||
points.map((p) => p.lineId).toSet().toList()..sort();
|
||
|
||
Map<String, ({int total, int staked})> get lineProgress {
|
||
final m = <String, ({int total, int staked})>{};
|
||
for (final p in points) {
|
||
final cur = m[p.lineId] ?? (total: 0, staked: 0);
|
||
m[p.lineId] = (
|
||
total: cur.total + 1,
|
||
staked: cur.staked + (p.status == StakeoutStatus.staked ? 1 : 0),
|
||
);
|
||
}
|
||
return m;
|
||
}
|
||
|
||
void setTarget(StakeoutPoint p) {
|
||
target.value = p;
|
||
_manualPhase = null; // új célnál vissza automatikus fázisra
|
||
_toleranceAnnounced = false;
|
||
_recompute();
|
||
}
|
||
|
||
void togglePhase() {
|
||
_manualPhase = !nearPhase.value;
|
||
_applyPhase();
|
||
}
|
||
|
||
StakeoutPoint? _firstPending() {
|
||
final pending =
|
||
points.where((p) => p.status == StakeoutStatus.pending).toList();
|
||
if (pending.isEmpty) return null;
|
||
pending.sort((a, b) => a.lineId != b.lineId
|
||
? a.lineId.compareTo(b.lineId)
|
||
: a.station.compareTo(b.station));
|
||
return orderMode.value == StakeoutOrder.idDesc
|
||
? pending.last
|
||
: pending.first;
|
||
}
|
||
|
||
/// Következő cél a sorrend-mód szerint — a CÉL VONALÁN belül lép,
|
||
/// elfogyva a következő vonalra.
|
||
StakeoutPoint? nextTarget({bool backwards = false}) {
|
||
final cur = target.value;
|
||
if (cur == null) return _firstPending();
|
||
final pending = points
|
||
.where((p) => p.status == StakeoutStatus.pending && p.uuid != cur.uuid)
|
||
.toList();
|
||
if (pending.isEmpty) return null;
|
||
|
||
final sameLine = pending.where((p) => p.lineId == cur.lineId).toList()
|
||
..sort((a, b) => a.station.compareTo(b.station));
|
||
|
||
switch (orderMode.value) {
|
||
case StakeoutOrder.nearest:
|
||
final pool = sameLine.isNotEmpty ? sameLine : pending;
|
||
pool.sort((a, b) => _distTo(a).compareTo(_distTo(b)));
|
||
return pool.first;
|
||
|
||
case StakeoutOrder.idAsc:
|
||
case StakeoutOrder.idDesc:
|
||
final asc = (orderMode.value == StakeoutOrder.idAsc) != backwards;
|
||
final candidates = sameLine.where(
|
||
(p) => asc ? p.station > cur.station : p.station < cur.station);
|
||
if (candidates.isNotEmpty) {
|
||
return asc
|
||
? candidates.reduce((a, b) => a.station < b.station ? a : b)
|
||
: candidates.reduce((a, b) => a.station > b.station ? a : b);
|
||
}
|
||
final others = pending.where((p) => p.lineId != cur.lineId).toList();
|
||
if (others.isEmpty) return null;
|
||
others.sort((a, b) => a.lineId != b.lineId
|
||
? a.lineId.compareTo(b.lineId)
|
||
: a.station.compareTo(b.station));
|
||
return asc ? others.first : others.last;
|
||
}
|
||
}
|
||
|
||
void advance({bool backwards = false}) {
|
||
final n = nextTarget(backwards: backwards);
|
||
if (n != null) setTarget(n);
|
||
}
|
||
|
||
double _distTo(StakeoutPoint p) {
|
||
final dy = p.planEovY - curEovY.value;
|
||
final dx = p.planEovX - curEovX.value;
|
||
return math.sqrt(dy * dy + dx * dx);
|
||
}
|
||
|
||
// ═════════════════════════════════════════════════════════════════
|
||
// Pozíció + eltérés
|
||
// ═════════════════════════════════════════════════════════════════
|
||
|
||
void _onPosition() {
|
||
final gnss = GnssService.to;
|
||
if (gnss.gpsQuality.value <= 0 ||
|
||
gnss.latitude.value == 0 ||
|
||
!Get.isRegistered<CoordConverterService>()) {
|
||
return;
|
||
}
|
||
final lat = gnss.latitude.value;
|
||
final lon = gnss.longitude.value;
|
||
final alt = gnss.altitude.value;
|
||
final sep = gnss.geoidSeparation.value;
|
||
|
||
final p = CoordConverterService.to.wgsToEovPoint(lon, lat);
|
||
curEovY.value = p.x;
|
||
curEovX.value = p.y;
|
||
|
||
curAlt.value = geoidGrid.toEovHeight(lat, lon, alt, sep)!;
|
||
|
||
//curAlt.value = gnss.altitude.value;
|
||
hasPosition.value = true;
|
||
|
||
// Haladási irány: legalább 0,5 m elmozdulásból (állva zajos lenne).
|
||
if (_histY != null) {
|
||
final dy = curEovY.value - _histY!;
|
||
final dx = curEovX.value - _histX!;
|
||
if (math.sqrt(dy * dy + dx * dx) >= 0.5) {
|
||
travelHeading.value = _bearingDeg(dy, dx);
|
||
_histY = curEovY.value;
|
||
_histX = curEovX.value;
|
||
}
|
||
} else {
|
||
_histY = curEovY.value;
|
||
_histX = curEovX.value;
|
||
}
|
||
|
||
_recompute();
|
||
}
|
||
|
||
void _recompute() {
|
||
final t = target.value;
|
||
if (t == null || !hasPosition.value) {
|
||
withinTolerance.value = false;
|
||
return;
|
||
}
|
||
|
||
final dy = t.planEovY - curEovY.value;
|
||
final dx = t.planEovX - curEovX.value;
|
||
distance.value = math.sqrt(dy * dy + dx * dx);
|
||
bearingToTarget.value = _bearingDeg(dy, dx);
|
||
|
||
final double fwdBearing;
|
||
switch (deviationMode.value) {
|
||
case DeviationMode.line:
|
||
fwdBearing = lineBearingAt(t) ?? travelHeading.value ?? 0;
|
||
case DeviationMode.travel:
|
||
fwdBearing = travelHeading.value ?? 0;
|
||
case DeviationMode.northEast:
|
||
fwdBearing = 0;
|
||
}
|
||
|
||
final rad = fwdBearing * math.pi / 180;
|
||
devForward.value = dy * math.sin(rad) + dx * math.cos(rad);
|
||
devRight.value = dy * math.cos(rad) - dx * math.sin(rad);
|
||
devDz.value = t.planEovZ != null ? t.planEovZ! - curAlt.value : null;
|
||
|
||
final wasWithin = withinTolerance.value;
|
||
withinTolerance.value = distance.value <= toleranceXY.value;
|
||
|
||
if (active.value) {
|
||
_applyPhase();
|
||
if (withinTolerance.value && !wasWithin && !_toleranceAnnounced) {
|
||
_toleranceAnnounced = true;
|
||
if (hapticsEnabled.value) HapticFeedback.heavyImpact();
|
||
if (soundEnabled.value) SystemSound.play(SystemSoundType.alert);
|
||
} else if (!withinTolerance.value) {
|
||
_toleranceAnnounced = false;
|
||
}
|
||
_scheduleHaptic();
|
||
}
|
||
}
|
||
|
||
void _applyPhase() {
|
||
nearPhase.value = _manualPhase ??
|
||
(hasPosition.value &&
|
||
target.value != null &&
|
||
distance.value <= nearPhaseDistance);
|
||
}
|
||
|
||
/// Haptikus "geiger": közeledve sűrűsödő pulzus, tűrésen belül gyors.
|
||
void _scheduleHaptic() {
|
||
_hapticTimer?.cancel();
|
||
if (!active.value ||
|
||
!hapticsEnabled.value ||
|
||
!hasPosition.value ||
|
||
target.value == null) {
|
||
return;
|
||
}
|
||
final d = distance.value;
|
||
if (d > 30) return;
|
||
|
||
final ms = withinTolerance.value
|
||
? 150
|
||
: d <= 1
|
||
? 250
|
||
: d <= 3
|
||
? 450
|
||
: d <= 10
|
||
? 800
|
||
: 1500;
|
||
|
||
_hapticTimer = Timer(Duration(milliseconds: ms), () {
|
||
if (withinTolerance.value) {
|
||
HapticFeedback.mediumImpact();
|
||
} else {
|
||
HapticFeedback.lightImpact();
|
||
}
|
||
if (soundEnabled.value) SystemSound.play(SystemSoundType.click);
|
||
_scheduleHaptic();
|
||
});
|
||
}
|
||
|
||
static double _bearingDeg(double dy, double dx) {
|
||
final b = math.atan2(dy, dx) * 180 / math.pi;
|
||
return (b + 360) % 360;
|
||
}
|
||
|
||
// ── Vonal-geometria ──────────────────────────────────────────────
|
||
|
||
List<StakeoutPoint> _linePoints(String lineId) {
|
||
final lp = points.where((p) => p.lineId == lineId && !p.isOffset).toList()
|
||
..sort((a, b) => a.station.compareTo(b.station));
|
||
return lp;
|
||
}
|
||
|
||
/// A vonal iránya (fok) az adott pontnál, a station-növekedés felé.
|
||
double? lineBearingAt(StakeoutPoint p) {
|
||
final lp = _linePoints(p.lineId);
|
||
if (lp.length < 2) return null;
|
||
var idx = lp.indexWhere((e) => e.uuid == p.uuid);
|
||
if (idx < 0) {
|
||
// Eltolt pont: a legközelebbi vonalpont szerint.
|
||
var bestD = double.infinity;
|
||
for (var k = 0; k < lp.length; k++) {
|
||
final d = math.pow(lp[k].planEovY - p.planEovY, 2) +
|
||
math.pow(lp[k].planEovX - p.planEovX, 2);
|
||
if (d < bestD) {
|
||
bestD = d.toDouble();
|
||
idx = k;
|
||
}
|
||
}
|
||
}
|
||
|
||
double segBearing(StakeoutPoint a, StakeoutPoint b) =>
|
||
_bearingDeg(b.planEovY - a.planEovY, b.planEovX - a.planEovX);
|
||
|
||
if (idx == 0) return segBearing(lp[0], lp[1]);
|
||
if (idx == lp.length - 1) return segBearing(lp[idx - 1], lp[idx]);
|
||
final b1 = segBearing(lp[idx - 1], lp[idx]) * math.pi / 180;
|
||
final b2 = segBearing(lp[idx], lp[idx + 1]) * math.pi / 180;
|
||
return _bearingDeg(
|
||
math.sin(b1) + math.sin(b2), math.cos(b1) + math.cos(b2));
|
||
}
|
||
|
||
// ═════════════════════════════════════════════════════════════════
|
||
// Műveletek (adatbázis: AppDatabase)
|
||
// ═════════════════════════════════════════════════════════════════
|
||
|
||
/// Tárolás a jelenlegi (vagy átlagolt) mért pozícióval. Ha az
|
||
/// [averagingSeconds] > 0, a megadott ideig gyűjti és átlagolja a
|
||
/// pozíciókat — csökkenti a pillanatnyi zaj hatását. A rekordba az
|
||
/// eltérés mindig vonal-relatívan (inline/crossline) kerül; vonal
|
||
/// híján É/K bontásban.
|
||
Future<StakeoutPoint?> storeCurrent() async {
|
||
final t = target.value;
|
||
if (t == null || !hasPosition.value || isAveraging.value) return null;
|
||
final gnss = GnssService.to;
|
||
|
||
double useY = curEovY.value;
|
||
double useX = curEovX.value;
|
||
double useAlt = curAlt.value;
|
||
|
||
if (averagingSeconds.value > 0) {
|
||
final avg = await _collectAverage(averagingSeconds.value);
|
||
useY = avg.y;
|
||
useX = avg.x;
|
||
useAlt = avg.alt;
|
||
}
|
||
|
||
final dy = t.planEovY - useY;
|
||
final dx = t.planEovX - useX;
|
||
final lineBearing = lineBearingAt(t);
|
||
final rad = (lineBearing ?? 0) * math.pi / 180;
|
||
final inline =
|
||
lineBearing != null ? dy * math.sin(rad) + dx * math.cos(rad) : dx;
|
||
final crossline =
|
||
lineBearing != null ? dy * math.cos(rad) - dx * math.sin(rad) : dy;
|
||
|
||
final w = CoordConverterService.to.eovToWgsPoint(useY, useX);
|
||
|
||
final updated = t.copyWith(
|
||
status: StakeoutStatus.staked,
|
||
measuredEovY: useY,
|
||
measuredEovX: useX,
|
||
measuredEovZ: useAlt,
|
||
measuredLat: w.y,
|
||
measuredLon: w.x,
|
||
devInline: inline,
|
||
devCrossline: crossline,
|
||
devDz: t.planEovZ != null ? t.planEovZ! - useAlt : null,
|
||
fixQuality: gnss.gpsQuality.value,
|
||
accuracy: gnss.horizontalAccuracy,
|
||
stakedAt: DateTime.now(),
|
||
);
|
||
await _db.updateStakeoutPoint(updated);
|
||
final i = points.indexWhere((p) => p.uuid == t.uuid);
|
||
if (i >= 0) points[i] = updated;
|
||
points.refresh();
|
||
return updated;
|
||
}
|
||
|
||
/// Pozíció-átlagolás: [seconds] másodpercig minden GGA-pozíciót
|
||
/// gyűjt, majd átlagol. Ha nem jött minta, a pillanatnyi értéket adja.
|
||
Future<({double y, double x, double alt})> _collectAverage(
|
||
int seconds) async {
|
||
isAveraging.value = true;
|
||
averagingElapsed.value = 0;
|
||
final ys = <double>[], xs = <double>[], alts = <double>[];
|
||
|
||
final worker = ever(curEovY, (_) {
|
||
ys.add(curEovY.value);
|
||
xs.add(curEovX.value);
|
||
alts.add(curAlt.value);
|
||
});
|
||
final ticker = Timer.periodic(
|
||
const Duration(seconds: 1), (_) => averagingElapsed.value++);
|
||
try {
|
||
await Future.delayed(Duration(seconds: seconds));
|
||
} finally {
|
||
worker.dispose();
|
||
ticker.cancel();
|
||
isAveraging.value = false;
|
||
}
|
||
|
||
if (ys.isEmpty) {
|
||
return (y: curEovY.value, x: curEovX.value, alt: curAlt.value);
|
||
}
|
||
double mean(List<double> l) => l.reduce((a, b) => a + b) / l.length;
|
||
return (y: mean(ys), x: mean(xs), alt: mean(alts));
|
||
}
|
||
|
||
Future<void> skipCurrent() async {
|
||
final t = target.value;
|
||
if (t == null) return;
|
||
final updated = t.copyWith(status: StakeoutStatus.skipped);
|
||
await _db.updateStakeoutPoint(updated);
|
||
final i = points.indexWhere((p) => p.uuid == t.uuid);
|
||
if (i >= 0) points[i] = updated;
|
||
points.refresh();
|
||
advance();
|
||
}
|
||
|
||
/// Státusz-állítás a listából (kihagyás / visszaállítás).
|
||
Future<void> setPointStatus(StakeoutPoint p, StakeoutStatus status) async {
|
||
final updated = p.copyWith(status: status);
|
||
await _db.updateStakeoutPoint(updated);
|
||
final i = points.indexWhere((e) => e.uuid == p.uuid);
|
||
if (i >= 0) points[i] = updated;
|
||
points.refresh();
|
||
if (target.value?.uuid == p.uuid && status != StakeoutStatus.pending) {
|
||
advance();
|
||
}
|
||
}
|
||
|
||
/// Pont törlése (soft delete — a szinkron viszi a többi eszközre is).
|
||
Future<void> deletePoint(StakeoutPoint p) async {
|
||
await _db.softDeleteStakeoutPoint(p.id!);
|
||
points.removeWhere((e) => e.uuid == p.uuid);
|
||
if (target.value?.uuid == p.uuid) {
|
||
target.value = _firstPending();
|
||
_recompute();
|
||
}
|
||
}
|
||
|
||
/// Transzverzális eltolt pont: a vonalra merőlegesen [dist] méterre
|
||
/// ([toRight] = jobbra a station-növekedés irányából nézve). Az új
|
||
/// pont lesz a cél; az eltolás-vektor a rekordba kerül.
|
||
Future<StakeoutPoint?> createOffset(
|
||
{required double dist, required bool toRight}) async {
|
||
final t = target.value;
|
||
if (t == null) return null;
|
||
|
||
final base = lineBearingAt(t) ?? travelHeading.value ?? 0;
|
||
final bearing = (base + (toRight ? 90 : -90) + 360) % 360;
|
||
final rad = bearing * math.pi / 180;
|
||
final eovY = t.planEovY + dist * math.sin(rad);
|
||
final eovX = t.planEovX + dist * math.cos(rad);
|
||
final w = CoordConverterService.to.eovToWgsPoint(eovY, eovX);
|
||
|
||
final offset = StakeoutPoint(
|
||
projectId: t.projectId,
|
||
lineId: t.lineId,
|
||
station: t.station,
|
||
name: '${t.name}/E',
|
||
pointType: t.pointType,
|
||
source: 'offset',
|
||
planEovY: eovY,
|
||
planEovX: eovX,
|
||
planEovZ: t.planEovZ,
|
||
planLat: w.y,
|
||
planLon: w.x,
|
||
isOffset: true,
|
||
parentUuid: t.uuid,
|
||
offsetDist: dist,
|
||
offsetBearing: bearing,
|
||
);
|
||
final id = await _db.insertStakeoutPoint(offset);
|
||
final saved = offset.copyWith(id: id);
|
||
points.add(saved);
|
||
setTarget(saved);
|
||
return saved;
|
||
}
|
||
}
|