// #pragma once // could not use by INCLUDE_HPP

#ifndef TROP_BORDERS_H

#define TROP_BORDERS_H

#include <memory></memory>

// TnzCore includes

#include "tsmartpointer.h"

#include "tgeometry.h"

#include "traster.h"

#include "trastercm.h"

// tcg includes

#include "tcg_wrap.h"

#include "tcg/tcg_vertex.h"

#include "tcg/tcg_edge.h"

#include "tcg/tcg_face.h"

#include "tcg/tcg_mesh.h"

// TRop::borders includes

#include "../common/trop/pixelselectors.h"

#include "../common/trop/raster_edge_iterator.h"

#include "../common/trop/borders_extractor.h"

#undef DVAPI

#undef DVVAR

#ifdef TROP_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//==============================================================================

/*!

  The TRop::borders namespace contains functions and classes that perform

  contours extraction of a specified raster (either greyscale, fullcolor

  or colormap).

  Image contours are currently extracted in a not-hierarchycal fashion

  (ie in succession) and supplied through a reimplementable reader class.

*/

//==============================================================================

namespace TRop {

namespace borders {

// Standard type instantiations

template class DVAPI RasterEdgeIterator<pixelselector<tpixel32>>;</pixelselector<tpixel32>

template class DVAPI RasterEdgeIterator<pixelselector<tpixel64>>;</pixelselector<tpixel64>

template class DVAPI RasterEdgeIterator<pixelselector<tpixelgr8>>;</pixelselector<tpixelgr8>

template class DVAPI RasterEdgeIterator<pixelselector<tpixelgr16>>;</pixelselector<tpixelgr16>

template class DVAPI RasterEdgeIterator<pixelselector<tpixelcm32>>;</pixelselector<tpixelcm32>

//**********************************************************************

//    Borders Extraction Reader  (callbacks container)

//**********************************************************************

/*!

  The BordersReader class defines the supported callbacks fired from the

  borders extraction routines.

*/

class DVAPI BordersReader {

public:

  virtual void openContainer(const TPoint &pos, const TPoint &dir,

                             const TPixel32 &innerColor,

                             const TPixel32 &outerColor) {}

  virtual void openContainer(const TPoint &pos, const TPoint &dir,

                             const TPixel64 &innerColor,

                             const TPixel64 &outerColor) {}

  virtual void openContainer(const TPoint &pos, const TPoint &dir,

                             const TPixelGR8 &innerColor,

                             const TPixelGR8 &outerColor) {}

  virtual void openContainer(const TPoint &pos, const TPoint &dir,

                             const TPixelGR16 &innerColor,

                             const TPixelGR16 &outerColor) {}

  virtual void openContainer(const TPoint &pos, const TPoint &dir,

                             TUINT32 innerColorIdx, TUINT32 outerColorIdx) {

  }  // colormap

  virtual void addElement(const TPoint &pos, const TPoint &dir,

                          const TPixel32 &outerColor) {}

  virtual void addElement(const TPoint &pos, const TPoint &dir,

                          const TPixel64 &outerColor) {}

  virtual void addElement(const TPoint &pos, const TPoint &dir,

                          const TPixelGR8 &outerColor) {}

  virtual void addElement(const TPoint &pos, const TPoint &dir,

                          const TPixelGR16 &outerColor) {}

  virtual void addElement(const TPoint &pos, const TPoint &dir,

                          TUINT32 outerColorIdx) {}

  virtual void closeContainer() {}

};

//**********************************************************************

//    Borders Extraction functions

//**********************************************************************

// Generic readBorders

void DVAPI readBorders_simple(const TRasterP &raster, BordersReader &reader,

                              bool onlyCorners = true);

// Greymap readBorders with transparency color

void DVAPI readBorders_simple(const TRasterGR8P &raster, BordersReader &reader,

                              const TPixelGR8 &transparencyColor,

                              bool onlyCorners = true);

void DVAPI readBorders_simple(const TRasterGR16P &raster, BordersReader &reader,

                              const TPixelGR16 &transparencyColor,

                              bool onlyCorners = true);

// Colormap readBorders with ink/paint antialias chooser

void DVAPI readBorders_simple(const TRasterCM32P &raster, BordersReader &reader,

                              bool onlyCorners = true, int toneThreshold = 128);

//**********************************************************************

//    Mesh Extraction (classes)

//**********************************************************************

typedef tcg::Vertex<tpoint> Vertex;</tpoint>

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

class Edge final : public tcg::Edge {

  TPoint m_directions[2];

  int m_imageIndex;

public:

  const TPoint &direction(int i) const { return m_directions[i]; }

  TPoint &direction(int i) { return m_directions[i]; }

  //! The edge index in the overall image extraction procedure. This value can

  //! be used to

  //! univocally associate external data to an image edge.

  int imageIndex() const { return m_imageIndex; }

  int &imageIndex() { return m_imageIndex; }

};

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

class Face final : public tcg::Face {

  tcg::list<int> m_meshes;</int>

  int m_imageIndex;

public:

  const tcg::list<int> &meshes() const { return m_meshes; }</int>

  tcg::list<int> &meshes() { return m_meshes; }</int>

  int meshesCount() const { return m_meshes.size(); }

  int mesh(int m) const { return m_meshes[m]; }

  //! The face index in the overall image extraction procedure. This value can

  //! be used to

  //! univocally associate external data to an image face.

  int imageIndex() const { return m_imageIndex; }

  int &imageIndex() { return m_imageIndex; }

};

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

class ImageMesh final : public TSmartObject,

                        public tcg::Mesh<vertex, edge,="" face=""> {};</vertex,>

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

}

}  // namespace TRop::borders

#ifdef _WIN32

template class DVAPI TSmartPointerT<trop::borders::imagemesh>;</trop::borders::imagemesh>

#endif

namespace TRop {

namespace borders {

typedef TSmartPointerT<imagemesh> ImageMeshP;</imagemesh>

//**********************************************************************

//    Mesh Extraction (reader)

//**********************************************************************

class DVAPI ImageMeshesReader {

  class Imp;

  std::unique_ptr<imp> m_imp;</imp>

public:

  ImageMeshesReader();

  virtual ~ImageMeshesReader();

  const Face &outerFace() const;

  Face &outerFace();

  const tcg::list<imagemeshp> &meshes() const;</imagemeshp>

  tcg::list<imagemeshp> &meshes();</imagemeshp>

  void clear();

public:

  // Face reader functions. Nested meshes are stored by default in a

  // global list of meshes retrievable with the meshes() accessor.

  // Each Mesh Face will be filled with the list of its sub-meshes in

  // the form of indices to the global list.

  void openFace(ImageMesh *mesh, int faceIdx);

  void addMesh(ImageMesh *mesh);

  void closeFace();

public:

  void closeEdge(ImageMesh *mesh, int edgeIdx);

private:

  // Not implemented

  ImageMeshesReader(const ImageMeshesReader &);

  ImageMeshesReader &operator=(const ImageMeshesReader &);

};

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

template <typename pixel=""></typename>

class ImageMeshesReaderT : public ImageMeshesReader {

public:

  typedef PixelSelector<pixel> pixel_selector_type;</pixel>

  typedef typename pixel_selector_type::value_type value_type;

  typedef RasterEdgeIterator<pixel_selector_type> raster_edge_iterator;</pixel_selector_type>

protected:

  pixel_selector_type m_selector;

public:

  ImageMeshesReaderT() : m_selector(false) {}

  ImageMeshesReaderT(const pixel_selector_type &selector)

      : m_selector(selector) {}

  ~ImageMeshesReaderT() {}

  const pixel_selector_type &pixelSelector() const { return m_selector; }

public:

  virtual void openFace(ImageMesh *mesh, int faceIdx,

                        const value_type &colorValue) {

    ImageMeshesReader::openFace(mesh, faceIdx);

  }

  virtual void addMesh(ImageMesh *mesh) { ImageMeshesReader::addMesh(mesh); }

  virtual void closeFace() { ImageMeshesReader::closeFace(); }

public:

  // Edge reader functions. Edges are not stored by default.

  // Users should reimplement these methods to store or process edge

  // data for the required purpose.

  virtual void openEdge(const raster_edge_iterator &it) {}

  virtual void addVertex(const raster_edge_iterator &it) {}

  virtual void closeEdge(ImageMesh *mesh, int edgeIdx) {

    ImageMeshesReader::closeEdge(mesh, edgeIdx);

  }

};

//**********************************************************************

//    Mesh Extraction (functions)

//**********************************************************************

template <typename pixel=""></typename>

void readMeshes(const TRasterPT<pixel> &raster,</pixel>

                ImageMeshesReaderT<pixel> &reader);</pixel>

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

}

}  // namespace TRop::borders

#endif  // TROP_BORDERS_H

#ifdef INCLUDE_HPP

#include "../common/trop/borders_extractor.hpp"

#include "../common/trop/raster_edge_iterator.hpp"

#endif