IntensityMap.h

/* Copyright (c) Queen's Printer for Ontario, 2020. */
/* Copyright (c) His Majesty the King in Right of Canada as represented by the Minister of Natural Resources, 2025. */
 
/* SPDX-License-Identifier: AGPL-3.0-or-later */
 
#pragma once
#include <memory>
#include <string>
#include <bitset>
#include "GridMap.h"
#include "Location.h"
namespace fs
{
namespace topo
{
class Perimeter;
class Cell;
}
namespace sim
{
using fs::topo::Position;
class ProbabilityMap;
class Model;
using BurnedData = std::bitset<static_cast<size_t>(MAX_ROWS) * MAX_COLUMNS>;
class IntensityMap
{
  mutable mutex mutex_{};
public:
  // IntensityMap(const Model& model, topo::Perimeter* perimeter) noexcept;
  explicit IntensityMap(const Model& model) noexcept;
  ~IntensityMap() noexcept;
  IntensityMap(const IntensityMap& rhs);
  IntensityMap(IntensityMap&& rhs) = delete;
  // IntensityMap(IntensityMap&& rhs);
  IntensityMap& operator=(const IntensityMap& rhs) = delete;
  IntensityMap& operator=(IntensityMap&& rhs) noexcept = delete;
  [[nodiscard]] Idx rows() const
  {
    return intensity_max_->rows();
  }
  [[nodiscard]] Idx columns() const
  {
    return intensity_max_->columns();
  }
  void applyPerimeter(const topo::Perimeter& perimeter) noexcept;
  [[nodiscard]] bool canBurn(const Location& location) const;
  template <class P>
  [[nodiscard]] bool canBurn(const Position<P>& position) const
  {
    return canBurn(Location{position.hash()});
  }
  [[nodiscard]] bool hasBurned(const Location& location) const;
  template <class P>
  [[nodiscard]] bool hasBurned(const Position<P>& position) const
  {
    return hasBurned(Location{position.hash()});
  }
  [[nodiscard]] bool isSurrounded(const Location& location) const;
  template <class P>
  [[nodiscard]] bool isSurrounded(const Position<P>& position) const
  {
    return isSurrounded(Location{position.hash()});
  }
  void ignite(const Location& location);
  template <class P>
  void ignite(const Position<P>& position)
  {
    ignite(Location{position.hash()});
  }
public:
  void burn(const Location& location,
            IntensitySize intensity,
            MathSize ros,
            fs::wx::Direction raz);
  template <class P>
  void burn(const Position<P>& position,
            const IntensitySize intensity,
            const MathSize ros,
            const fs::wx::Direction& raz)
  {
    burn(
      Location{position.hash()},
      intensity,
      ros,
      raz);
  }
  void save(const string& dir, const string& base_name) const;
  [[nodiscard]] MathSize fireSize() const;
  [[nodiscard]] map<Location, IntensitySize>::const_iterator
    cbegin() const noexcept;
  [[nodiscard]] map<Location, IntensitySize>::const_iterator
    cend() const noexcept;
private:
  const Model& model_;
  unique_ptr<data::GridMap<IntensitySize>> intensity_max_;
  // HACK: just add ROS/RAZ into this object for now
  unique_ptr<data::GridMap<MathSize>> rate_of_spread_at_max_;
  unique_ptr<data::GridMap<DegreesSize>> direction_of_spread_at_max_;
  BurnedData* is_burned_;
};
}
}