570 lines
18 KiB
C++
570 lines
18 KiB
C++
#pragma once
|
|
|
|
#ifndef BORDERS_EXTRACTOR_HPP
|
|
#define BORDERS_EXTRACTOR_HPP
|
|
|
|
// Toonz includes
|
|
#include "raster_edge_iterator.h"
|
|
|
|
// tcg includes
|
|
#include "tcg/tcg_traits.h"
|
|
#include "tcg/tcg_containers_reader.h"
|
|
#include "tcg/tcg_hash.h"
|
|
#include "tcg/tcg_misc.h"
|
|
|
|
#include "borders_extractor.h"
|
|
|
|
namespace TRop {
|
|
namespace borders {
|
|
|
|
//*********************************************************************************************************
|
|
// Private stuff
|
|
//*********************************************************************************************************
|
|
|
|
template <typename PixelSelector>
|
|
class _DummyReader {
|
|
public:
|
|
void openContainer(const RasterEdgeIterator<PixelSelector> &) {}
|
|
void addElement(const RasterEdgeIterator<PixelSelector> &) {}
|
|
void closeContainer() {}
|
|
};
|
|
|
|
//*********************************************************************************************************
|
|
// Borders Extraction procedure
|
|
//*********************************************************************************************************
|
|
|
|
inline void _signEdge(RunsMapP &runsMap, int x, int y0, int y1,
|
|
UCHAR increasingSign, UCHAR decreasingSign) {
|
|
for (; y0 < y1; ++y0) runsMap->runHeader(x, y0) |= increasingSign;
|
|
|
|
if (y0 > y1) {
|
|
--x;
|
|
do {
|
|
--y0;
|
|
runsMap->runHeader(x, y0) |= decreasingSign;
|
|
} while (y0 > y1);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
template <typename Pixel, typename PixelSelector, typename ContainerReader>
|
|
void _readBorder(const TRasterPT<Pixel> &rin, const PixelSelector &selector,
|
|
RunsMapP &runsMap, int x, int y, bool counter,
|
|
ContainerReader &reader) {
|
|
typedef typename PixelSelector::value_type value_type;
|
|
|
|
UCHAR increasingSign = _BORDER_LEFT, decreasingSign = _BORDER_RIGHT;
|
|
if (!counter)
|
|
increasingSign |= _HIERARCHY_INCREASE,
|
|
decreasingSign |= _HIERARCHY_DECREASE;
|
|
|
|
// First, read the border entirely, while erasing the border from
|
|
// the runsMap.
|
|
RasterEdgeIterator<PixelSelector> it(rin, selector, TPoint(x, y),
|
|
counter ? TPoint(1, 0) : TPoint(0, 1));
|
|
//++it; //As we could be in the middle of a straight edge, increment to get
|
|
//a corner
|
|
|
|
TPoint start(it.pos()), startDir(it.dir());
|
|
reader.openContainer(it);
|
|
|
|
TPoint oldPos(start);
|
|
for (++it; it.pos() != start || it.dir() != startDir; ++it) {
|
|
const TPoint &currPos(it.pos());
|
|
reader.addElement(it);
|
|
|
|
// Sign the corresponding (vertical) edge
|
|
_signEdge(runsMap, oldPos.x, oldPos.y, currPos.y, increasingSign,
|
|
decreasingSign);
|
|
|
|
oldPos = currPos;
|
|
}
|
|
|
|
_signEdge(runsMap, oldPos.x, oldPos.y, it.pos().y, increasingSign,
|
|
decreasingSign);
|
|
|
|
reader.closeContainer();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
template <typename Pixel, typename PixelSelector, typename ContainerReader>
|
|
void readBorders(const TRasterPT<Pixel> &rin, const PixelSelector &selector,
|
|
ContainerReader &reader, RunsMapP *rasterRunsMap) {
|
|
typedef TRasterPT<Pixel> RasterTypeP;
|
|
typedef _DummyReader<PixelSelector> DummyReader;
|
|
|
|
// First, extract the run-length representation for rin
|
|
RunsMapP runsMap;
|
|
if (rasterRunsMap && *rasterRunsMap) {
|
|
// If it was supplied, use it
|
|
runsMap = *rasterRunsMap;
|
|
runsMap->lock();
|
|
} else {
|
|
// In case, build it anew
|
|
runsMap = RunsMapP(rin->getLx(), rin->getLy());
|
|
|
|
runsMap->lock();
|
|
buildRunsMap(runsMap, rin, selector);
|
|
}
|
|
|
|
if (rasterRunsMap)
|
|
// Return the runsMap if requested
|
|
*rasterRunsMap = runsMap;
|
|
|
|
// Build a fake reader for internal borders
|
|
DummyReader dummyReader;
|
|
|
|
// Now, use it to extract borders - iterate through runs and, whenever
|
|
// one is found with opaque color (ie not transparent), extract its
|
|
// associated border. The border is erased internally after the read.
|
|
int lx = rin->getLx(), ly = rin->getLy();
|
|
|
|
int hierarchyLevel = 0;
|
|
|
|
int x, y;
|
|
for (y = 0; y < ly; ++y) {
|
|
Pixel *lineStart = rin->pixels(y), *pix;
|
|
TPixelGR8 *runsStart = runsMap->pixels(y), *run;
|
|
|
|
UCHAR nextHeader, prevHeader = 0;
|
|
for (x = 0, pix = lineStart, run = runsStart; x < lx;) {
|
|
nextHeader = run->value;
|
|
|
|
if (hierarchyLevel) {
|
|
if (prevHeader & _BORDER_RIGHT) {
|
|
if (prevHeader & _HIERARCHY_DECREASE) --hierarchyLevel;
|
|
} else // Every right border in a region should be signed. Do so now.
|
|
_readBorder(rin, selector, runsMap, x, y, true, dummyReader);
|
|
}
|
|
|
|
if (hierarchyLevel) {
|
|
if (nextHeader & _BORDER_LEFT) {
|
|
if (nextHeader & _HIERARCHY_INCREASE) ++hierarchyLevel;
|
|
} else {
|
|
++hierarchyLevel;
|
|
_readBorder(rin, selector, runsMap, x, y, false, reader);
|
|
}
|
|
} else {
|
|
if (!(selector.transparent(
|
|
*pix))) // External transparent region - do not extract
|
|
{
|
|
++hierarchyLevel;
|
|
if (!(nextHeader & _BORDER_LEFT))
|
|
_readBorder(rin, selector, runsMap, x, y, false, reader);
|
|
}
|
|
}
|
|
|
|
// Increment variables
|
|
x += runsMap->runLength(x, y), pix = lineStart + x, run = runsStart + x;
|
|
prevHeader = (run - 1)->value;
|
|
}
|
|
|
|
assert(x == lx);
|
|
|
|
if (hierarchyLevel) {
|
|
assert((prevHeader & _BORDER_RIGHT) &&
|
|
(prevHeader & _HIERARCHY_DECREASE));
|
|
--hierarchyLevel;
|
|
}
|
|
|
|
assert(!hierarchyLevel);
|
|
}
|
|
|
|
runsMap->unlock();
|
|
}
|
|
|
|
//*********************************************************************************************************
|
|
// New Mesh Extraction procedure
|
|
//*********************************************************************************************************
|
|
|
|
enum {
|
|
_PROCESSED = 0x1,
|
|
_HIERARCHY_UP = 0x2,
|
|
_HIERARCHY_DN = 0x4,
|
|
_PROCESSED_AND_HIERARCHY_UP = (_PROCESSED | _HIERARCHY_UP)
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename RasterEdgeIter>
|
|
inline bool _isVertex(
|
|
const RasterEdgeIter &it,
|
|
const typename RasterEdgeIter::value_type &oldOtherColor) {
|
|
return (it.otherColor() != oldOtherColor) ||
|
|
(it.turn() == it.adherence() &&
|
|
(!(it.turn() & RasterEdgeIter::AMBIGUOUS)) &&
|
|
it.elbowColor() != oldOtherColor);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
inline size_t _pointHash(const TPoint &point) { return point.x ^ point.y; }
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename RasterEdgeIter>
|
|
struct _ExternalEdgeSigner {
|
|
static inline void signAndIncrement(RunsMapP &runsMap, RasterEdgeIter &it) {
|
|
if (it.dir().y > 0) {
|
|
TPoint pos = it.pos();
|
|
int newY = (++it).pos().y;
|
|
|
|
for (; pos.y != newY; ++pos.y)
|
|
runsMap->runHeader(pos.x, pos.y) |= _PROCESSED_AND_HIERARCHY_UP;
|
|
} else if (it.dir().y < 0) {
|
|
TPoint pos = it.pos();
|
|
int newY = (++it).pos().y;
|
|
|
|
TPixelGR8 *pix = runsMap->pixels(pos.y - 1) + pos.x;
|
|
|
|
for (; pos.y != newY; --pos.y, --pix) {
|
|
pix->value |= _PROCESSED;
|
|
(--pix)->value |= _HIERARCHY_DN;
|
|
}
|
|
} else
|
|
++it;
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename RasterEdgeIter>
|
|
struct _InternalEdgeSigner {
|
|
static inline void signAndIncrement(RunsMapP &runsMap, RasterEdgeIter &it) {
|
|
if (it.dir().y) {
|
|
TPoint pos = it.pos();
|
|
int newY = (++it).pos().y;
|
|
int dir = it.dir().y;
|
|
|
|
TPixelGR8 *pix =
|
|
runsMap->pixels((it.dir().y > 0) ? pos.y : pos.y - 1) + pos.x;
|
|
|
|
for (; pos.y != newY; pos.y += dir, pix += dir) {
|
|
pix->value |= _PROCESSED_AND_HIERARCHY_UP;
|
|
(--pix)->value |= _HIERARCHY_DN;
|
|
}
|
|
} else
|
|
++it;
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename RasterEdgeIter, typename Mesh, typename ContainersReader,
|
|
typename EdgeSigner>
|
|
int _readEdge(RasterEdgeIter &it, const RasterEdgeIter &end, RunsMapP runsMap,
|
|
int &vIdx, Mesh &mesh, tcg::hash<TPoint, int> &pointsHash,
|
|
ContainersReader &reader) {
|
|
typedef tcg::container_reader_traits<ContainersReader,
|
|
typename Mesh::edge_type>
|
|
edge_output;
|
|
|
|
typename Mesh::edge_type ed;
|
|
|
|
ed.addVertex(vIdx);
|
|
ed.direction(0) = it.dir();
|
|
|
|
edge_output::openContainer(reader, it);
|
|
|
|
typename RasterEdgeIter::value_type oldOtherColor = it.otherColor();
|
|
do {
|
|
EdgeSigner::signAndIncrement(runsMap, it);
|
|
edge_output::addElement(reader, it);
|
|
|
|
} while ((it != end) && !_isVertex(it, oldOtherColor));
|
|
|
|
// Identify the newly found vertex. If it's a brand new one, add it
|
|
tcg::hash<TPoint, int>::iterator ht = pointsHash.find(it.pos());
|
|
vIdx = (ht == pointsHash.end())
|
|
? pointsHash[it.pos()] =
|
|
mesh.addVertex(typename Mesh::vertex_type(it.pos()))
|
|
: ht.m_idx;
|
|
|
|
ed.addVertex(vIdx);
|
|
ed.direction(1) = (it.turn() == RasterEdgeIter::STRAIGHT)
|
|
? -it.dir()
|
|
: (it.turn() == RasterEdgeIter::LEFT)
|
|
? tcg::point_ops::ortLeft(it.dir())
|
|
: tcg::point_ops::ortRight(it.dir());
|
|
|
|
int eIdx = mesh.addEdge(ed);
|
|
edge_output::closeContainer(reader, &mesh, eIdx);
|
|
|
|
return eIdx;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
template <typename RasterEdgeIter, typename Mesh, typename ContainersReader>
|
|
void _readMeshes(const RasterEdgeIter &begin, RunsMapP &runsMap,
|
|
ContainersReader &reader) {
|
|
typedef tcg::container_reader_traits<ContainersReader,
|
|
typename Mesh::face_type>
|
|
face_output;
|
|
|
|
// Iterate it clockwise. Process lines with vertical displacement. In each
|
|
// line, search
|
|
// for unprocessed raster edges.
|
|
|
|
// Use hierarchy signs in the runsMap to understand the search scope in this
|
|
// sub-region.
|
|
int hierarchyLevel = 0;
|
|
|
|
RasterEdgeIter it(begin);
|
|
do {
|
|
if (it.dir().y > 0) {
|
|
// Process line
|
|
TPoint pos = it.pos();
|
|
const TPixelGR8 *pix = runsMap->pixels(pos.y) + pos.x;
|
|
|
|
hierarchyLevel = 0;
|
|
assert((pix->value & _PROCESSED) && (pix->value & _HIERARCHY_UP));
|
|
|
|
do {
|
|
// Iterate through the line. Extract a mesh each time an unprocessed
|
|
// raster edge is found.
|
|
if (!(pix->value & _PROCESSED)) {
|
|
assert(hierarchyLevel == 1);
|
|
|
|
Mesh *meshPtr = new Mesh;
|
|
_readMesh(it.raster(), it.selector(), runsMap, pos.x, pos.y, *meshPtr,
|
|
reader);
|
|
|
|
face_output::addElement(reader, meshPtr);
|
|
}
|
|
|
|
if (pix->value & _HIERARCHY_UP) ++hierarchyLevel;
|
|
|
|
TUINT32 l = runsMap->runLength(pos.x, pos.y);
|
|
pos.x += l;
|
|
pix += l;
|
|
|
|
if ((pix - 1)->value & _HIERARCHY_DN) --hierarchyLevel;
|
|
|
|
} while (hierarchyLevel > 0);
|
|
}
|
|
|
|
++it;
|
|
|
|
} while (it != begin);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename RasterEdgeIter, typename Mesh, typename ContainersReader>
|
|
void _readBorder(const RasterEdgeIter &begin, RunsMapP runsMap, int vIdx,
|
|
Mesh &mesh, tcg::hash<TPoint, int> &pointsHash,
|
|
ContainersReader &reader) {
|
|
typedef typename Mesh::face_type face_type;
|
|
typedef typename Mesh::edge_type edge_type;
|
|
typedef tcg::container_reader_traits<ContainersReader,
|
|
typename Mesh::face_type>
|
|
face_output;
|
|
|
|
// As long as we don't get back to the initial iterator, extract edges
|
|
RasterEdgeIter it(begin);
|
|
|
|
// Create the face to be extracted at the right of processed border, and add
|
|
// it to
|
|
// the mesh. Observe that insertion is made manually in the mesh's faces list.
|
|
// This prevents the mesh from automatically link edges to the face.
|
|
face_type fc;
|
|
|
|
do {
|
|
// Retrieve current vertex
|
|
typename Mesh::vertex_type &vx = mesh.vertex(vIdx);
|
|
|
|
// Search in it the edge corresponding to current iterating direction
|
|
int e, edgesCount = vx.edgesCount(), eIdx = -1, side = -1;
|
|
for (e = 0; e < edgesCount; ++e) {
|
|
edge_type &ed = mesh.edge(vx.edge(e));
|
|
side = ed.vertex(0) == vIdx ? 0 : 1;
|
|
|
|
if (ed.direction(side) == it.dir()) {
|
|
eIdx = ed.getIndex();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (e == edgesCount) {
|
|
// In case the edge was not found, it needs to be extracted now.
|
|
eIdx = _readEdge<RasterEdgeIter, Mesh, ContainersReader,
|
|
_InternalEdgeSigner<RasterEdgeIter>>(
|
|
it, begin, runsMap, vIdx, mesh, pointsHash, reader);
|
|
} else {
|
|
// The edge was already extracted. We just need to update the iterator
|
|
// then.
|
|
const edge_type &ed = mesh.edge(eIdx);
|
|
|
|
vIdx = ed.vertex(1 - side);
|
|
const TPoint &oppositePos = mesh.vertex(vIdx).P();
|
|
const TPoint &oppositeDir = ed.direction(1 - side);
|
|
|
|
// We need to perform the last ++it in the already extracted edge since we
|
|
// need
|
|
// to give it the incoming direction.
|
|
it.setEdge(oppositePos + oppositeDir, -oppositeDir), ++it;
|
|
}
|
|
|
|
fc.addEdge(eIdx);
|
|
|
|
} while (it != begin);
|
|
|
|
// The face has now been described (from the mesh viewpoint). Add it to the
|
|
// mesh.
|
|
int fIdx = mesh.addFace(fc);
|
|
|
|
// We still need to extract its sub-meshes content now.
|
|
face_output::openContainer(reader, &mesh, fIdx, begin.rightColor());
|
|
|
|
_readMeshes<RasterEdgeIter, Mesh, ContainersReader>(begin, runsMap, reader);
|
|
|
|
face_output::closeContainer(reader);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename PixelSelector, typename Mesh, typename ContainersReader>
|
|
void _readMesh(const TRasterPT<typename PixelSelector::pixel_type> &rin,
|
|
const PixelSelector &selector, RunsMapP &runsMap, int x, int y,
|
|
Mesh &mesh, ContainersReader &reader) {
|
|
typedef typename Mesh::vertex_type vertex_type;
|
|
typedef typename Mesh::edge_type edge_type;
|
|
typedef tcg::container_reader_traits<ContainersReader, edge_type> edge_output;
|
|
typedef typename PixelSelector::value_type value_type;
|
|
typedef RasterEdgeIterator<PixelSelector> raster_edge_iterator;
|
|
|
|
// Iterate silently until a vertex is encountered (or until the initial point
|
|
// is found)
|
|
raster_edge_iterator it(rin, selector, TPoint(x, y), TPoint(0, 1)), begin(it);
|
|
it.setAdherence(raster_edge_iterator::LEFT);
|
|
|
|
value_type beginColor = begin.rightColor();
|
|
for (++it; it != begin && !_isVertex(it, beginColor); ++it)
|
|
;
|
|
|
|
// Use a hash to keep track of found vertices
|
|
tcg::hash<TPoint, int> pointsHash(&_pointHash);
|
|
|
|
int vIdx = pointsHash[it.pos()] = mesh.addVertex(it.pos());
|
|
|
|
// The outer edges are extracted first in clockwise orientation.
|
|
begin = it;
|
|
do {
|
|
_readEdge<raster_edge_iterator, Mesh, ContainersReader,
|
|
_ExternalEdgeSigner<raster_edge_iterator>>(
|
|
it, begin, runsMap, vIdx, mesh, pointsHash, reader);
|
|
|
|
} while (it != begin);
|
|
|
|
// Then, their associated faces are extracted.
|
|
it.setAdherence(raster_edge_iterator::RIGHT);
|
|
|
|
int e, outerEdgesCount = mesh.edgesCount();
|
|
for (e = 0; e < outerEdgesCount; ++e) {
|
|
const edge_type &ed = mesh.edge(e);
|
|
if (ed.face(0) < 0) {
|
|
vIdx = ed.vertex(0);
|
|
const vertex_type &vx = mesh.vertex(vIdx);
|
|
|
|
it.setEdge(vx.P(), ed.direction(0));
|
|
_readBorder(it, runsMap, vIdx, mesh, pointsHash, reader);
|
|
}
|
|
}
|
|
|
|
// Edges following those must have either side associated with a face.
|
|
// Which must be extracted too.
|
|
for (e = outerEdgesCount; e < mesh.edgesCount(); ++e) {
|
|
const edge_type &ed = mesh.edge(e);
|
|
if (ed.face(1) < 0) {
|
|
vIdx = ed.vertex(1);
|
|
const vertex_type &vx = mesh.vertex(vIdx);
|
|
|
|
it.setEdge(vx.P(), ed.direction(1));
|
|
_readBorder(it, runsMap, vIdx, mesh, pointsHash, reader);
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
template <typename PixelSelector, typename Mesh, typename ContainersReader>
|
|
void readMeshes(const TRasterPT<typename PixelSelector::pixel_type> &rin,
|
|
const PixelSelector &selector, ContainersReader &reader,
|
|
RunsMapP *rasterRunsMap) {
|
|
typedef typename PixelSelector::pixel_type pixel_type;
|
|
typedef TRasterPT<pixel_type> RasterTypeP;
|
|
typedef Mesh mesh_type;
|
|
typedef tcg::container_reader_traits<ContainersReader,
|
|
typename Mesh::face_type>
|
|
face_output;
|
|
|
|
// First, extract the run-length representation for rin
|
|
RunsMapP runsMap;
|
|
if (rasterRunsMap && *rasterRunsMap) {
|
|
// If a runsmap was supplied, use it
|
|
runsMap = *rasterRunsMap;
|
|
runsMap->lock();
|
|
|
|
assert((runsMap->getLx() == rin->getLx() + 1) &&
|
|
(runsMap->getLy() == rin->getLy()));
|
|
} else {
|
|
// In case, build it anew
|
|
runsMap = RunsMapP(rin->getLx() + 1, rin->getLy());
|
|
|
|
// Observe the +1 on the x-axis. One additional pixel is currently required
|
|
// on the right
|
|
// side of the runsmap - for ease of use in the algorithm.
|
|
|
|
runsMap->lock();
|
|
buildRunsMap(runsMap, rin, selector);
|
|
}
|
|
|
|
if (rasterRunsMap)
|
|
// Return the runsMap if requested
|
|
*rasterRunsMap = runsMap;
|
|
|
|
face_output::openContainer(reader, 0, -1, selector.transparent());
|
|
|
|
// Now, use it to extract borders - iterate through runs and, whenever
|
|
// one is found with opaque color (ie not transparent), extract its
|
|
// associated border. The border is erased internally after the read.
|
|
int lx = rin->getLx(), ly = rin->getLy();
|
|
|
|
int x, y;
|
|
for (y = 0; y < ly; ++y) {
|
|
// Process each row
|
|
|
|
pixel_type *lineStart = rin->pixels(y), *pix;
|
|
TPixelGR8 *runsStart = runsMap->pixels(y), *run;
|
|
|
|
UCHAR nextHeader, prevHeader = 0;
|
|
for (x = 0, pix = lineStart, run = runsStart; x < lx;) {
|
|
nextHeader = run->value;
|
|
|
|
if (!(selector.transparent(*pix) || nextHeader & _PROCESSED)) {
|
|
mesh_type *meshPtr = new mesh_type;
|
|
|
|
// Read the mesh. All its internal sub-meshes are read as well.
|
|
_readMesh(rin, selector, runsMap, x, y, *meshPtr, reader);
|
|
face_output::addElement(reader, meshPtr);
|
|
}
|
|
|
|
// Increment variables
|
|
x += runsMap->runLength(x, y), pix = lineStart + x, run = runsStart + x;
|
|
prevHeader = (run - 1)->value;
|
|
}
|
|
|
|
assert(x == lx);
|
|
}
|
|
|
|
face_output::closeContainer(reader);
|
|
|
|
runsMap->unlock();
|
|
}
|
|
}
|
|
} // namespace TRop::borders
|
|
|
|
#endif // BORDERS_EXTRACTOR_HPP
|