tahoma2d/toonz/sources/include/trop_borders.h
2017-06-06 21:19:00 +09:00

277 lines
9.2 KiB
C++

// #pragma once // could not use by INCLUDE_HPP
#ifndef TROP_BORDERS_H
#define TROP_BORDERS_H
#include <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>>;
template class DVAPI RasterEdgeIterator<PixelSelector<TPixel64>>;
template class DVAPI RasterEdgeIterator<PixelSelector<TPixelGR8>>;
template class DVAPI RasterEdgeIterator<PixelSelector<TPixelGR16>>;
template class DVAPI RasterEdgeIterator<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;
//--------------------------------------------------------------------------------
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 m_imageIndex;
public:
const tcg::list<int> &meshes() const { return m_meshes; }
tcg::list<int> &meshes() { return m_meshes; }
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> {};
//--------------------------------------------------------------------------------
}
} // namespace TRop::borders
#ifdef _WIN32
template class DVAPI TSmartPointerT<TRop::borders::ImageMesh>;
#endif
namespace TRop {
namespace borders {
typedef TSmartPointerT<ImageMesh> ImageMeshP;
//**********************************************************************
// Mesh Extraction (reader)
//**********************************************************************
class DVAPI ImageMeshesReader {
class Imp;
std::unique_ptr<Imp> m_imp;
public:
ImageMeshesReader();
virtual ~ImageMeshesReader();
const Face &outerFace() const;
Face &outerFace();
const tcg::list<ImageMeshP> &meshes() const;
tcg::list<ImageMeshP> &meshes();
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>
class ImageMeshesReaderT : public ImageMeshesReader {
public:
typedef PixelSelector<Pixel> pixel_selector_type;
typedef typename pixel_selector_type::value_type value_type;
typedef RasterEdgeIterator<pixel_selector_type> raster_edge_iterator;
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>
void readMeshes(const TRasterPT<Pixel> &raster,
ImageMeshesReaderT<Pixel> &reader);
//--------------------------------------------------------------------------------
}
} // namespace TRop::borders
#endif // TROP_BORDERS_H
#ifdef INCLUDE_HPP
#include "../common/trop/borders_extractor.hpp"
#include "../common/trop/raster_edge_iterator.hpp"
#endif