327 lines
9.7 KiB
C++
327 lines
9.7 KiB
C++
|
|
|
|
// Local includes
|
|
#include "pixelselectors.h"
|
|
#include "runsmap.h"
|
|
|
|
// STD includes
|
|
#include <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>
|
|
class WrapperReader {
|
|
TRop::borders::BordersReader &m_reader;
|
|
|
|
public:
|
|
WrapperReader(TRop::borders::BordersReader &reader) : m_reader(reader) {}
|
|
|
|
void openContainer(const RasterEdgeIterator<PixelSelector> &it) {
|
|
m_reader.openContainer(it.pos(), it.dir(), it.rightColor(), it.leftColor());
|
|
}
|
|
void addElement(const RasterEdgeIterator<PixelSelector> &it) {
|
|
m_reader.addElement(it.pos(), it.dir(), it.leftColor());
|
|
}
|
|
void closeContainer() { m_reader.closeContainer(); }
|
|
};
|
|
|
|
} // namespace
|
|
|
|
//****************************************************************
|
|
// Borders Extractor instantiations
|
|
//****************************************************************
|
|
|
|
namespace TRop {
|
|
namespace borders {
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
// Standard type instantiations
|
|
|
|
template void DVAPI readMeshes<TPixel32>(const TRasterPT<TPixel32> &raster,
|
|
ImageMeshesReaderT<TPixel32> &reader);
|
|
template void DVAPI readMeshes<TPixel64>(const TRasterPT<TPixel64> &raster,
|
|
ImageMeshesReaderT<TPixel64> &reader);
|
|
template void DVAPI readMeshes<TPixelGR8>(
|
|
const TRasterPT<TPixelGR8> &raster, ImageMeshesReaderT<TPixelGR8> &reader);
|
|
template void DVAPI
|
|
readMeshes<TPixelGR16>(const TRasterPT<TPixelGR16> &raster,
|
|
ImageMeshesReaderT<TPixelGR16> &reader);
|
|
template void DVAPI
|
|
readMeshes<TPixelCM32>(const TRasterPT<TPixelCM32> &raster,
|
|
ImageMeshesReaderT<TPixelCM32> &reader);
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
template <typename Pix>
|
|
void readBorders_simple(const TRasterPT<Pix> &raster, BordersReader &reader,
|
|
bool onlyCorners) {
|
|
typedef PixelSelector<Pix> pixel_selector;
|
|
|
|
pixel_selector selector(onlyCorners);
|
|
WrapperReader<pixel_selector> wrapReader(reader);
|
|
|
|
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;
|
|
|
|
pixel_selector selector(onlyCorners, transparencyColor);
|
|
WrapperReader<pixel_selector> wrapReader(reader);
|
|
|
|
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;
|
|
|
|
pixel_selector selector(onlyCorners, transparencyColor);
|
|
WrapperReader<pixel_selector> wrapReader(reader);
|
|
|
|
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;
|
|
|
|
pixel_selector selector(onlyCorners, toneThreshold);
|
|
WrapperReader<pixel_selector> wrapReader(reader);
|
|
|
|
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;
|
|
|
|
std::stack<Face *> m_facesStack;
|
|
|
|
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 {
|
|
return m_imp->m_meshes;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
tcg::list<ImageMeshP> &ImageMeshesReader::meshes() { 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>
|
|
struct container_reader_traits<ImageMeshesReaderT<Pixel>,
|
|
ImageMesh::face_type> {
|
|
typedef ImageMeshesReaderT<Pixel> meshes_reader_type;
|
|
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>
|
|
struct container_reader_traits<ImageMeshesReaderT<Pixel>,
|
|
ImageMesh::edge_type> {
|
|
typedef ImageMeshesReaderT<Pixel> meshes_reader_type;
|
|
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>
|
|
void readMeshes(const TRasterPT<Pix> &raster, ImageMeshesReaderT<Pix> &reader) {
|
|
typedef PixelSelector<Pix> pixel_selector;
|
|
|
|
reader.clear();
|
|
|
|
raster->lock();
|
|
readMeshes<pixel_selector, ImageMesh, ImageMeshesReaderT<Pix>>(
|
|
raster, reader.pixelSelector(), reader);
|
|
raster->unlock();
|
|
}
|
|
}
|
|
} // namespace TRop::borders
|