// Local includes

#include "pixelselectors.h"

#include "runsmap.h"

// STD includes

#include <stack></stack>

// tcg includes

#include "tcg/tcg_traits.h"

#include "tcg/tcg_vertex.h"

#include "tcg/tcg_edge.h"

#include "tcg/tcg_face.h"

#define INCLUDE_HPP

#include "tcg/tcg_mesh.h"

#include "raster_edge_iterator.h"

#include "borders_extractor.h"

#undef INCLUDE_HPP

#include "trop_borders.h"

using namespace TRop::borders;

namespace {

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

//    Container Reader for Borders Reader

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

template <typename pixelselector=""></typename>

class WrapperReader {

  TRop::borders::BordersReader &m_reader;

public:

  WrapperReader(TRop::borders::BordersReader &reader) : m_reader(reader) {}

  void openContainer(const RasterEdgeIterator<pixelselector> &it) {</pixelselector>

    m_reader.openContainer(it.pos(), it.dir(), it.rightColor(), it.leftColor());

  }

  void addElement(const RasterEdgeIterator<pixelselector> &it) {</pixelselector>

    m_reader.addElement(it.pos(), it.dir(), it.leftColor());

  }

  void closeContainer() { m_reader.closeContainer(); }

};

}  // namespace

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

//    Borders Extractor instantiations

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

namespace TRop {

namespace borders {

template <typename pix=""></typename>

void readBorders_simple(const TRasterPT<pix> &raster, BordersReader &reader,</pix>

                        bool onlyCorners) {

  typedef PixelSelector<pix> pixel_selector;</pix>

  pixel_selector selector(onlyCorners);

  WrapperReader<pixel_selector> wrapReader(reader);</pixel_selector>

  raster->lock();

  readBorders(raster, selector, wrapReader);

  raster->unlock();

}

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

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

                        const TPixelGR8 &transparencyColor, bool onlyCorners) {

  typedef PixelSelector<tpixelgr8> pixel_selector;</tpixelgr8>

  pixel_selector selector(onlyCorners, transparencyColor);

  WrapperReader<pixel_selector> wrapReader(reader);</pixel_selector>

  raster->lock();

  readBorders(raster, selector, wrapReader);

  raster->unlock();

}

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

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

                        const TPixelGR16 &transparencyColor, bool onlyCorners) {

  typedef PixelSelector<tpixelgr16> pixel_selector;</tpixelgr16>

  pixel_selector selector(onlyCorners, transparencyColor);

  WrapperReader<pixel_selector> wrapReader(reader);</pixel_selector>

  raster->lock();

  readBorders(raster, selector, wrapReader);

  raster->unlock();

}

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

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

                        bool onlyCorners, int toneThreshold) {

  typedef PixelSelector<tpixelcm32> pixel_selector;</tpixelcm32>

  pixel_selector selector(onlyCorners, toneThreshold);

  WrapperReader<pixel_selector> wrapReader(reader);</pixel_selector>

  raster->lock();

  readBorders(raster, selector, wrapReader);

  raster->unlock();

}

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

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

                        bool onlyCorners) {

  TRaster32P ras32(raster);

  if (ras32) {

    readBorders_simple(ras32, reader, onlyCorners);

    return;

  }

  TRaster64P ras64(raster);

  if (ras64) {

    readBorders_simple(ras64, reader, onlyCorners);

    return;

  }

  TRasterCM32P rasCM32(raster);

  if (rasCM32) {

    readBorders_simple(rasCM32, reader, onlyCorners);

    return;

  }

  TRasterGR8P rasGR8(raster);

  if (rasGR8) {

    readBorders_simple(rasGR8, reader, onlyCorners);

    return;

  }

  TRasterGR16P rasGR16(raster);

  if (rasGR16) {

    readBorders_simple(rasGR16, reader, onlyCorners);

    return;

  }

}

}

}  // namespace TRop::borders

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

//    Meshes Extraction (MeshesReader::Imp)

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

namespace TRop {

namespace borders {

class TRop::borders::ImageMeshesReader::Imp {

public:

  Face m_outerFace;

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

  std::stack<face *=""> m_facesStack;</face>

  int m_facesCount, m_edgesCount;

public:

  Imp() : m_facesCount(), m_edgesCount() {}

  void clear() {

    assert(m_facesStack.empty());

    m_outerFace = Face();

    m_meshes.clear();

    m_facesCount = m_edgesCount = 0;

  }

};

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

//    Meshes Extraction (MeshesReader)

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

ImageMeshesReader::ImageMeshesReader() : m_imp(new Imp) {}

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

ImageMeshesReader::~ImageMeshesReader() {}

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

void ImageMeshesReader::clear() { m_imp->clear(); }

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

const Face &ImageMeshesReader::outerFace() const { return m_imp->m_outerFace; }

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

Face &ImageMeshesReader::outerFace() { return m_imp->m_outerFace; }

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

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

  return m_imp->m_meshes;

}

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

tcg::list<imagemeshp> &ImageMeshesReader::meshes() { return m_imp->m_meshes; }</imagemeshp>

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

void ImageMeshesReader::openFace(ImageMesh *mesh, int faceIdx) {

  Face &fc        = mesh ? mesh->face(faceIdx) : m_imp->m_outerFace;

  fc.imageIndex() = m_imp->m_facesCount++;

  m_imp->m_facesStack.push(&fc);

}

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

void ImageMeshesReader::addMesh(ImageMesh *mesh) {

  Face &fc = *m_imp->m_facesStack.top();

  fc.meshes().push_back(m_imp->m_meshes.push_back(mesh));

}

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

void ImageMeshesReader::closeFace() { m_imp->m_facesStack.pop(); }

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

void ImageMeshesReader::closeEdge(ImageMesh *mesh, int edgeIdx) {

  mesh->edge(edgeIdx).imageIndex() = m_imp->m_edgesCount++;

}

}

}  //  namespace TRop::borders

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

//    Meshes Extraction (traits)

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

namespace tcg {

using namespace TRop::borders;

// Reader traits

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

struct container_reader_traits<imagemeshesreadert<pixel>,</imagemeshesreadert<pixel>

                               ImageMesh::face_type> {

  typedef ImageMeshesReaderT<pixel> meshes_reader_type;</pixel>

  typedef typename meshes_reader_type::value_type value_type;

public:

  inline static void openContainer(meshes_reader_type &reader, ImageMesh *mesh,

                                   int faceIdx, const value_type &colorValue) {

    reader.openFace(mesh, faceIdx, colorValue);

  }

  inline static void addElement(meshes_reader_type &reader, ImageMesh *mesh) {

    reader.addMesh(mesh);

  }

  inline static void closeContainer(meshes_reader_type &reader) {

    reader.closeFace();

  }

};

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

struct container_reader_traits<imagemeshesreadert<pixel>,</imagemeshesreadert<pixel>

                               ImageMesh::edge_type> {

  typedef ImageMeshesReaderT<pixel> meshes_reader_type;</pixel>

  typedef

      typename meshes_reader_type::raster_edge_iterator raster_edge_iterator;

public:

  inline static void openContainer(meshes_reader_type &reader,

                                   const raster_edge_iterator &it) {

    reader.openEdge(it);

  }

  inline static void addElement(meshes_reader_type &reader,

                                const raster_edge_iterator &it) {

    reader.addVertex(it);

  }

  inline static void closeContainer(meshes_reader_type &reader, ImageMesh *mesh,

                                    int edgeIdx) {

    reader.closeEdge(mesh, edgeIdx);

  }

};

}  // namespace tcg

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

//    Meshes Extraction (functions)

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

namespace TRop {

namespace borders {

template <typename pix=""></typename>

void readMeshes(const TRasterPT<pix> &raster, ImageMeshesReaderT<pix> &reader) {</pix></pix>

  typedef PixelSelector<pix> pixel_selector;</pix>

  reader.clear();

  raster->lock();

  readMeshes<pixel_selector, imagemesh,="" imagemeshesreadert<pix="">>(</pixel_selector,>

      raster, reader.pixelSelector(), reader);

  raster->unlock();

}

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

// Standard type instantiations

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

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

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

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

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

template DV_EXPORT_API void readMeshes<tpixel32>(</tpixel32>

    const TRasterPT<tpixel32> &raster, ImageMeshesReaderT<tpixel32> &reader);</tpixel32></tpixel32>

template DV_EXPORT_API void readMeshes<tpixel64>(</tpixel64>

    const TRasterPT<tpixel64> &raster, ImageMeshesReaderT<tpixel64> &reader);</tpixel64></tpixel64>

template DV_EXPORT_API void readMeshes<tpixelgr8>(</tpixelgr8>

    const TRasterPT<tpixelgr8> &raster, ImageMeshesReaderT<tpixelgr8> &reader);</tpixelgr8></tpixelgr8>

template DV_EXPORT_API void readMeshes<tpixelgr16>(</tpixelgr16>

    const TRasterPT<tpixelgr16> &raster,</tpixelgr16>

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

template DV_EXPORT_API void readMeshes<tpixelcm32>(</tpixelcm32>

    const TRasterPT<tpixelcm32> &raster,</tpixelcm32>

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

}

}  // namespace TRop::borders