Graphs

1_drawMoonCurve(canvas, width, height);

1// 2. Draw Cloud Cover (Area Chart)2_drawCloudCover(canvas, width, height);

1/// Combines cloud and moon scores with appropriate weighting2/// Cloud cover is weighted more heavily (70%) than moon (30%)3double _calculateCombinedScore(double cloudScore, double moonScore) {4  const double cloudWeight = 0.7;5  const double moonWeight = 0.3;6  return (cloudScore * cloudWeight) + (moonScore * moonWeight);7}

1// Find the best contiguous window2return _findBestContiguousWindow(scores, minWindowHours);

1// 3. Draw Object Curve2_drawObjectCurve(canvas, size);

1// 2. Draw Moon Interference (if any)2_drawMoonInterference(canvas, size);

1// 6. Draw Peak Altitude (Blue Circle)2_drawPeakIndicator(canvas, size);

1void _updateScrubber(double dx, double width, VisibilityGraphData data) {2  if (width <= 0) return;3  final double position = (dx / width).clamp(0.0, 1.0);4  5  final int totalDuration = data.objectCurve.last.time.difference(data.objectCurve.first.time).inMinutes;6  final int minutesFromStart = (position * totalDuration).round();7  final DateTime time = data.objectCurve.first.time.add(Duration(minutes: minutesFromStart));89  // Find closest altitude point10  double? altitude;11  try {12    final GraphPoint point = data.objectCurve.reduce((GraphPoint a, GraphPoint b) {13      final Duration diffA = a.time.difference(time).abs();14      final Duration diffB = b.time.difference(time).abs();15      return diffA < diffB ? a : b;16    });17    altitude = point.value;18  } catch (e) {19    // ignore20  }2122  setState(() {23    _scrubberPosition = position;24    _scrubbedTime = time;25    _scrubbedAltitude = altitude;26  });27}

1@override2Future<Either<Failure, VisibilityGraphData>> calculateVisibility({3  required CelestialObject object,4  required GeoLocation location,5  required DateTime startTime,6  DateTime? endTime,7}) async {8  try {9    final Duration duration = endTime != null 10        ? endTime.difference(startTime) 11        : const Duration(hours: 12);1213    // 1. Calculate Object Trajectory14    List<GraphPoint> objectCurve;15    16    // Check for Ephemeris ID first (Planets, Sun, Moon)17    if (object.ephemerisId != null) {18      final HeavenlyBody? body = _mapToHeavenlyBody(object);19      if (body != null) {20      objectCurve = await _astronomyService.calculateAltitudeTrajectory(21          body: body,22          startTime: startTime,23          lat: location.latitude,24          long: location.longitude,25          duration: duration,26        );27      } else {28         return Left(CalculationFailure('Failed to map object with ephemerisId to HeavenlyBody: ${object.name}'));29      }30    } 31    // Check for RA/Dec (Stars, DSOs)32    else if (object.ra != null && object.dec != null) {33      objectCurve = await _astronomyService.calculateFixedObjectTrajectory(34        ra: object.ra!,35        dec: object.dec!,36        startTime: startTime,37        lat: location.latitude,38        long: location.longitude,39        duration: duration,40      );41    } else {42      return Left(CalculationFailure('Unsupported celestial object: ${object.name} (No Ephemeris ID or RA/Dec)'));43    }4445    // 2. Calculate Moon Trajectory46    final List<GraphPoint> moonCurve = await _astronomyService.calculateMoonTrajectory(47      startTime: startTime,48      lat: location.latitude,49      long: location.longitude,50      duration: duration,51    );5253    // 3. Calculate Optimal Windows54    // Logic: Object Altitude > 30 AND Moon Interference < 30 (arbitrary threshold, maybe 10?)55    // Let's use 30 for now as per previous mock logic.56    const double minObjectAltitude = 30;57    const double maxMoonInterference = 30;58    final List<TimeRange> optimalRanges = <TimeRange>[];59    DateTime? windowStart;6061    for (int i = 0; i < objectCurve.length; i++) {62      final GraphPoint objectPoint = objectCurve[i];63      // Ensure we have a matching moon point (should be same length)64      final GraphPoint moonPoint = i < moonCurve.length ? moonCurve[i] : GraphPoint(time: objectPoint.time, value: 0);65      66      final double objectAlt = objectPoint.value;67      final double moonInterference = moonPoint.value;6869      final bool isOptimal = objectAlt > minObjectAltitude && moonInterference < maxMoonInterference;7071      if (isOptimal && windowStart == null) {72        windowStart = objectPoint.time;73      } else if (!isOptimal && windowStart != null) {74        optimalRanges.add(TimeRange(start: windowStart, end: objectPoint.time));75        windowStart = null;76      }77    }7879    // Close open window80    if (windowStart != null) {81      optimalRanges.add(TimeRange(start: windowStart, end: objectCurve.last.time));82    }8384    // 4. Calculate Sun/Moon Rise/Set Times85    final Map<String, DateTime?> sunTimes = await _astronomyService.calculateRiseSetTransit(86      body: HeavenlyBody.SE_SUN,87      date: startTime,88      lat: location.latitude,89      long: location.longitude,90    );91    92    final Map<String, DateTime?> moonTimes = await _astronomyService.calculateRiseSetTransit(93      body: HeavenlyBody.SE_MOON,94      date: startTime,95      lat: location.latitude,96      long: location.longitude,97    );9899    return Right(VisibilityGraphData(100      objectCurve: objectCurve,101      moonCurve: moonCurve,102      optimalWindows: optimalRanges,103      sunRise: sunTimes['rise'],104      sunSet: sunTimes['set'],105      moonRise: moonTimes['rise'],106      moonSet: moonTimes['set'],107    ));108  } catch (e) {109    return Left(CalculationFailure('Error calculating visibility: $e'));110  }111}

1/// Selects the top 3 highlights from a list of celestial positions.2///3/// Logic:4/// 1. Filter objects with Altitude > 10 degrees.5/// 2. Exclude the Sun (as it's not a stargazing target).6/// 3. Sort by Magnitude (ascending, lower is brighter).7/// 4. Take the top 3.8static List<HighlightItem> selectTop3({9  required List<CelestialPosition> positions,10}) {11  // 0. Determine if it's "Daytime" (Sun Altitude > -6 degrees, i.e., Civil Twilight)12  double sunAltitude = -90;13  try {14    final CelestialPosition sunPos = positions.firstWhere((CelestialPosition p) => p.body == CelestialBody.sun);15    sunAltitude = sunPos.altitude;16  } catch (e) {17    // Sun not found in list, assume night or handle gracefully18  }1920  final bool isDaytime = sunAltitude > -6.0;2122  // 1. Filter visible objects23  final List<CelestialPosition> visibleObjects = positions.where((CelestialPosition pos) {24    // Ensure body is not null25    if (pos.body == null) return false;2627    // Always exclude Sun from highlights28    if (pos.body == CelestialBody.sun) return false;2930    // Basic visibility check (above horizon + buffer)31    if (pos.altitude <= 10.0) return false;3233    // Daytime Logic:34    // If it's daytime, ONLY the Moon is visible.35    // Planets/Stars are washed out by the Sun.36    if (isDaytime) {37      return pos.body == CelestialBody.moon;38    }3940    return true;41  }).toList();4243  // 2. Sort by Magnitude (ascending)44  // Note: For MVP, we treat all remaining bodies (Moon, Planets) as high priority.45  // We sort purely by brightness.46  visibleObjects.sort((CelestialPosition a, CelestialPosition b) => a.magnitude.compareTo(b.magnitude));4748  // 3. Take Top 349  final List<CelestialPosition> top3 = visibleObjects.take(3).toList();5051  // 4. Map to HighlightItem52  return top3.map((CelestialPosition pos) => HighlightItem(53    body: pos.body!,54    altitude: pos.altitude,55    magnitude: pos.magnitude,56    isVisible: true,57  )).toList();58}

1static String _getMoonPhaseLabel(MoonPhaseInfo info) {2  final double angle = info.phaseAngle;34  if (angle >= 355 || angle <= 5) return 'New Moon';5  if (angle > 5 && angle < 85) return 'Waxing Crescent';6  if (angle >= 85 && angle <= 95) return 'First Quarter';7  if (angle > 95 && angle < 175) return 'Waxing Gibbous';8  if (angle >= 175 && angle <= 185) return 'Full Moon';9  if (angle > 185 && angle < 265) return 'Waning Gibbous';10  if (angle >= 265 && angle <= 275) return 'Last Quarter';11  if (angle > 275 && angle < 355) return 'Waning Crescent';1213  return 'Moon';14}

1/// Effective sky brightness in mag/arcsec²: natural + artificial + moon + twilight, in natural units.2static double sqmEffective(double rArt, {double bMoon = 0, double bTwilight = 0}) =>3    AstrZoneScale.referenceSqm -4    2.5 * _log10(1 + math.max(rArt, 0) + math.max(bMoon, 0) + math.max(bTwilight, 0));

1/// Per-hour values. [cloud] is a fraction 0 to 1.2static SkyHour hourQuality({3  required bool dark,4  required double cloud,5  required double rArt,6  required double bMoon,7}) {8  final double sqm = sqmEffective(rArt, bMoon: bMoon);9  final double nelm = AstrZoneScale.nelmFromSqm(sqm);10  final bool usable = dark && cloud <= cloudUsableMax && nelm >= nelmUsableMin;11  final double utility = usable ? (1 - cloud) * relativeStarCount(nelm) : 0;12  return SkyHour(13    dark: dark,14    cloud: cloud,15    rArt: rArt,16    bMoon: bMoon,17    sqm: sqm,18    nelm: nelm,19    usable: usable,20    utility: utility,21  );22}

1/// The run of usable hours with the greatest summed utility, or null. Ties go to the earlier run.2static SkyWindow? bestWindow(List<SkyHour> hours, {int minHours = minWindowHours}) {3  SkyWindow? best;4  double bestUtility = 0;5  int i = 0;6  while (i < hours.length) {7    if (!hours[i].usable) {8      i++;9      continue;10    }11    int j = i;12    double total = 0;13    while (j < hours.length && hours[j].usable) {14      total += hours[j].utility;15      j++;16    }17    if (j - i >= minHours && total > bestUtility) {18      best = SkyWindow(i, j);19      bestUtility = total;20    }21    i = j;22  }23  return best;24}

1/// Angle between two directions given as altitude and azimuth in degrees.2static double angularSeparationDeg(double alt1, double az1, double alt2, double az2) {3  final double a1 = _rad(alt1);4  final double a2 = _rad(alt2);5  final double c = math.sin(a1) * math.sin(a2) + math.cos(a1) * math.cos(a2) * math.cos(_rad(az1 - az2));6  return _deg(math.acos(c.clamp(-1.0, 1.0)));7}