#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2015 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GEOMETRY_PARTITIONING_VORONOIMESH2_H
#define NUCLEX_GEOMETRY_PARTITIONING_VORONOIMESH2_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Point2.h"

#include <vector>

namespace Nuclex { namespace Geometry { namespace Partitioning {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Describes the voronoi cell around one of the input elements</summary>
  class VoronoiCell2 {

    /// <summary>Index of the element this voronoi cell encompasses</summary>
    /// <remarks>
    ///   This is the index of the input element (point or line segment) around which this
    ///   cell has been built. The voronoi mesh does not save the input elements, if you
    ///   need to reference them, you need to save the input 
    /// </remarks>
    public: std::size_t PointIndex;

    /// <summary>Indices of the vertices that make up the voronoi cell's outline</summary>
    public: std::vector<std::size_t> Outline;

  };

  // ------------------------------------------------------------------------------------------- //

  /// <summary>2D mesh forming the voronoi regions of a set of points</summary>
  template <typename TScalar>
  struct VoronoiMesh2 {

    /// <summary>Vertex index that indicates an edge extends to infinity</summary>
    /// <remarks>
    ///   All non-empty voronoi graphs have at least 2 edges that extend to infinity. To
    ///   represent these, the edges are given one vertex at unit length from its neighbor
    ///   that indicates the direction, followed by this invalid index.
    /// </remarks>
    public: const std::size_t InfinityVertexIndex = std::size_t(-1);

    /// <summary>Type of points the voronoi mesh is working with</summary>
    public: typedef Point2<TScalar> PointType;

    /// <summary>Offsets the entire voronoi graph by the specified amount</summary>
    /// <param name="amountX">Amount the graph will be offset on the X axis</param>
    /// <param name="amountY">Amount the graph will be offset on the Y axis</param>
    public: void ShiftBy(TScalar amountX, TScalar amountY) {
      for(std::size_t index = 0; index < this->count; ++index) {
        this->vertices[index].X += amountX;
        this->vertices[index].Y += amountY;
      }
    }

    /// <summary>Offsets the entire voronoi graph by the specified amount</summary>
    /// <param name="amount">Amount the graph will be offset</param>
    public: void ShiftBy(const Vector2<TScalar> &amount) {
      for(std::size_t index = 0; index < this->count; ++index) {
        this->Vertices[index] += amount;
      }
    }

    /// <summary>Vertices used by the voronoi graph</summary>
    public: std::vector<PointType> Vertices;

    /// <summary>Indices that connect the vorono graph to a complete mesh</summary>
    /// <remarks>
    ///   As described in the <see cref="InfinityVertexIndex" /> constant, a non-empty voronoi
    ///   graph has at least two edges ending in infinity that are represented by connecting
    ///   to a special infinity vertex index.
    /// </remarks>
    public: std::vector<std::size_t> Indices;

    /// <summary>Voronoi cells around the input elements</summary>
    /// <remarks>
    ///   Exterior cells have an infinite side. See the description of the
    ///   <see cref="InfinityVertexIndex" /> constant on how to spot them and how to work
    ///   with them.
    /// </remarks>
    public: std::vector<VoronoiCell2> Cells;

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Geometry::Partitioning

#endif // NUCLEX_GEOMETRY_PARTITIONING_VORONOIMESH2_H