// 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, bool onlyCorners)</pix>

{

	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()

{

	delete m_imp;

}

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

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()</imagemeshp>

{

	return m_imp->m_meshes;

}

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

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>, ImageMesh::face_type> {</imagemeshesreadert<pixel>

	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>, ImageMesh::edge_type> {</imagemeshesreadert<pixel>

	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="">>(raster, reader.pixelSelector(), reader);</pixel_selector,>

	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>(const TRasterPT<tpixel32> &raster, ImageMeshesReaderT<tpixel32> &reader);</tpixel32></tpixel32></tpixel32>

template DV_EXPORT_API void readMeshes<tpixel64>(const TRasterPT<tpixel64> &raster, ImageMeshesReaderT<tpixel64> &reader);</tpixel64></tpixel64></tpixel64>

template DV_EXPORT_API void readMeshes<tpixelgr8>(const TRasterPT<tpixelgr8> &raster, ImageMeshesReaderT<tpixelgr8> &reader);</tpixelgr8></tpixelgr8></tpixelgr8>

template DV_EXPORT_API void readMeshes<tpixelgr16>(const TRasterPT<tpixelgr16> &raster, ImageMeshesReaderT<tpixelgr16> &reader);</tpixelgr16></tpixelgr16></tpixelgr16>

template DV_EXPORT_API void readMeshes<tpixelcm32>(const TRasterPT<tpixelcm32> &raster, ImageMeshesReaderT<tpixelcm32> &reader);</tpixelcm32></tpixelcm32></tpixelcm32>

}

} //namespace TRop::borders