You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
282 lines
9.7 KiB
282 lines
9.7 KiB
// David Eberly, Geometric Tools, Redmond WA 98052
|
|
// Copyright (c) 1998-2021
|
|
// Distributed under the Boost Software License, Version 1.0.
|
|
// https://www.boost.org/LICENSE_1_0.txt
|
|
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
|
|
// Version: 4.0.2019.08.13
|
|
|
|
#pragma once
|
|
|
|
#include <Mathematics/Logger.h>
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <map>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
namespace gte
|
|
{
|
|
// The image type T must be one of the integer types: int8_t, int16_t,
|
|
// int32_t, uint8_t, uint16_t or uint32_t. Internal integer computations
|
|
// are performed using int64_t. The type Real is for extraction to
|
|
// floating-point vertices.
|
|
template <typename T, typename Real>
|
|
class CurveExtractor
|
|
{
|
|
public:
|
|
// Abstract base class.
|
|
virtual ~CurveExtractor() = default;
|
|
|
|
// The level curves form a graph of vertices and edges. The vertices
|
|
// are computed as pairs of nonnegative rational numbers. Vertex
|
|
// represents the rational pair (xNumer/xDenom, yNumer/yDenom) as
|
|
// (xNumer, xDenom, yNumer, yDenom), where all components are
|
|
// nonnegative. The edges connect pairs of vertices, forming a graph
|
|
// that represents the level set.
|
|
struct Vertex
|
|
{
|
|
Vertex() = default;
|
|
|
|
Vertex(int64_t inXNumer, int64_t inXDenom, int64_t inYNumer, int64_t inYDenom)
|
|
{
|
|
// The vertex generation leads to the numerator and
|
|
// denominator having the same sign. This constructor changes
|
|
// sign to ensure the numerator and denominator are both
|
|
// positive.
|
|
if (inXDenom > 0)
|
|
{
|
|
xNumer = inXNumer;
|
|
xDenom = inXDenom;
|
|
}
|
|
else
|
|
{
|
|
xNumer = -inXNumer;
|
|
xDenom = -inXDenom;
|
|
}
|
|
|
|
if (inYDenom > 0)
|
|
{
|
|
yNumer = inYNumer;
|
|
yDenom = inYDenom;
|
|
}
|
|
else
|
|
{
|
|
yNumer = -inYNumer;
|
|
yDenom = -inYDenom;
|
|
}
|
|
}
|
|
|
|
// The non-default constructor guarantees that xDenom > 0 and
|
|
// yDenom > 0. The following comparison operators assume that
|
|
// the denominators are positive.
|
|
bool operator==(Vertex const& other) const
|
|
{
|
|
return
|
|
// xn0 / xd0 == xn1 / xd1
|
|
xNumer * other.xDenom == other.xNumer * xDenom
|
|
&&
|
|
// yn0/yd0 == yn1/yd1
|
|
yNumer * other.yDenom == other.yNumer * yDenom;
|
|
}
|
|
|
|
bool operator<(Vertex const& other) const
|
|
{
|
|
int64_t xn0txd1 = xNumer * other.xDenom;
|
|
int64_t xn1txd0 = other.xNumer * xDenom;
|
|
if (xn0txd1 < xn1txd0)
|
|
{
|
|
// xn0/xd0 < xn1/xd1
|
|
return true;
|
|
}
|
|
if (xn0txd1 > xn1txd0)
|
|
{
|
|
// xn0/xd0 > xn1/xd1
|
|
return false;
|
|
}
|
|
|
|
int64_t yn0tyd1 = yNumer * other.yDenom;
|
|
int64_t yn1tyd0 = other.yNumer * yDenom;
|
|
// yn0/yd0 < yn1/yd1
|
|
return yn0tyd1 < yn1tyd0;
|
|
}
|
|
|
|
int64_t xNumer, xDenom, yNumer, yDenom;
|
|
};
|
|
|
|
struct Edge
|
|
{
|
|
Edge() = default;
|
|
|
|
Edge(int v0, int v1)
|
|
{
|
|
if (v0 < v1)
|
|
{
|
|
v[0] = v0;
|
|
v[1] = v1;
|
|
}
|
|
else
|
|
{
|
|
v[0] = v1;
|
|
v[1] = v0;
|
|
}
|
|
}
|
|
|
|
bool operator==(Edge const& other) const
|
|
{
|
|
return v[0] == other.v[0] && v[1] == other.v[1];
|
|
}
|
|
|
|
bool operator<(Edge const& other) const
|
|
{
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
if (v[i] < other.v[i])
|
|
{
|
|
return true;
|
|
}
|
|
if (v[i] > other.v[i])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::array<int, 2> v;
|
|
};
|
|
|
|
// Extract level curves and return rational vertices.
|
|
virtual void Extract(T level, std::vector<Vertex>& vertices,
|
|
std::vector<Edge>& edges) = 0;
|
|
|
|
void Extract(T level, bool removeDuplicateVertices,
|
|
std::vector<std::array<Real, 2>>& vertices, std::vector<Edge>& edges)
|
|
{
|
|
std::vector<Vertex> rationalVertices;
|
|
Extract(level, rationalVertices, edges);
|
|
if (removeDuplicateVertices)
|
|
{
|
|
MakeUnique(rationalVertices, edges);
|
|
}
|
|
Convert(rationalVertices, vertices);
|
|
}
|
|
|
|
// The extraction has duplicate vertices on edges shared by pixels.
|
|
// This function will eliminate the duplicates.
|
|
void MakeUnique(std::vector<Vertex>& vertices, std::vector<Edge>& edges)
|
|
{
|
|
size_t numVertices = vertices.size();
|
|
size_t numEdges = edges.size();
|
|
if (numVertices == 0 || numEdges == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Compute the map of unique vertices and assign to them new and
|
|
// unique indices.
|
|
std::map<Vertex, int> vmap;
|
|
int nextVertex = 0;
|
|
for (size_t v = 0; v < numVertices; ++v)
|
|
{
|
|
// Keep only unique vertices.
|
|
auto result = vmap.insert(std::make_pair(vertices[v], nextVertex));
|
|
if (result.second)
|
|
{
|
|
++nextVertex;
|
|
}
|
|
}
|
|
|
|
// Compute the map of unique edges and assign to them new and
|
|
// unique indices.
|
|
std::map<Edge, int> emap;
|
|
int nextEdge = 0;
|
|
for (size_t e = 0; e < numEdges; ++e)
|
|
{
|
|
// Replace old vertex indices by new vertex indices.
|
|
Edge& edge = edges[e];
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
auto iter = vmap.find(vertices[edge.v[i]]);
|
|
LogAssert(iter != vmap.end(), "Expecting the vertex to be in the vmap.");
|
|
edge.v[i] = iter->second;
|
|
}
|
|
|
|
// Keep only unique edges.
|
|
auto result = emap.insert(std::make_pair(edge, nextEdge));
|
|
if (result.second)
|
|
{
|
|
++nextEdge;
|
|
}
|
|
}
|
|
|
|
// Pack the vertices into an array.
|
|
vertices.resize(vmap.size());
|
|
for (auto const& element : vmap)
|
|
{
|
|
vertices[element.second] = element.first;
|
|
}
|
|
|
|
// Pack the edges into an array.
|
|
edges.resize(emap.size());
|
|
for (auto const& element : emap)
|
|
{
|
|
edges[element.second] = element.first;
|
|
}
|
|
}
|
|
|
|
// Convert from Vertex to std::array<Real, 2> rationals.
|
|
void Convert(std::vector<Vertex> const& input, std::vector<std::array<Real, 2>>& output)
|
|
{
|
|
output.resize(input.size());
|
|
for (size_t i = 0; i < input.size(); ++i)
|
|
{
|
|
Real rxNumer = static_cast<Real>(input[i].xNumer);
|
|
Real rxDenom = static_cast<Real>(input[i].xDenom);
|
|
Real ryNumer = static_cast<Real>(input[i].yNumer);
|
|
Real ryDenom = static_cast<Real>(input[i].yDenom);
|
|
output[i][0] = rxNumer / rxDenom;
|
|
output[i][1] = ryNumer / ryDenom;
|
|
}
|
|
}
|
|
|
|
protected:
|
|
// The input is a 2D image with lexicographically ordered pixels (x,y)
|
|
// stored in a linear array. Pixel (x,y) is stored in the array at
|
|
// location index = x + xBound * y. The inputs xBound and yBound must
|
|
// each be 2 or larger so that there is at least one image square to
|
|
// process. The inputPixels must be nonnull and point to contiguous
|
|
// storage that contains at least xBound * yBound elements.
|
|
CurveExtractor(int xBound, int yBound, T const* inputPixels)
|
|
:
|
|
mXBound(xBound),
|
|
mYBound(yBound),
|
|
mInputPixels(inputPixels)
|
|
{
|
|
static_assert(std::is_integral<T>::value && sizeof(T) <= 4,
|
|
"Type T must be int{8,16,32}_t or uint{8,16,32}_t.");
|
|
LogAssert(mXBound > 1 && mYBound > 1 && mInputPixels != nullptr, "Invalid input.");
|
|
mPixels.resize(static_cast<size_t>(mXBound * mYBound));
|
|
}
|
|
|
|
void AddVertex(std::vector<Vertex>& vertices,
|
|
int64_t xNumer, int64_t xDenom, int64_t yNumer, int64_t yDenom)
|
|
{
|
|
vertices.push_back(Vertex(xNumer, xDenom, yNumer, yDenom));
|
|
}
|
|
|
|
void AddEdge(std::vector<Vertex>& vertices, std::vector<Edge>& edges,
|
|
int64_t xNumer0, int64_t xDenom0, int64_t yNumer0, int64_t yDenom0,
|
|
int64_t xNumer1, int64_t xDenom1, int64_t yNumer1, int64_t yDenom1)
|
|
{
|
|
int v0 = static_cast<int>(vertices.size());
|
|
int v1 = v0 + 1;
|
|
edges.push_back(Edge(v0, v1));
|
|
vertices.push_back(Vertex(xNumer0, xDenom0, yNumer0, yDenom0));
|
|
vertices.push_back(Vertex(xNumer1, xDenom1, yNumer1, yDenom1));
|
|
}
|
|
|
|
int mXBound, mYBound;
|
|
T const* mInputPixels;
|
|
std::vector<int64_t> mPixels;
|
|
};
|
|
}
|
|
|