407 lines
10 KiB
C++
407 lines
10 KiB
C++
|
|
|
|
// TnzCore includes
|
|
#include "tstream.h"
|
|
|
|
// tcg includes
|
|
#include "tcg/tcg_misc.h"
|
|
#include "tcg/tcg_iterator_ops.h"
|
|
|
|
#define INCLUDE_HPP
|
|
#include "tmeshimage.h"
|
|
#undef INCLUDE_HPP
|
|
|
|
//******************************************************************************
|
|
// Explicit instantiations
|
|
//******************************************************************************
|
|
|
|
template class DV_EXPORT_API tcg::Vertex<TPointD>;
|
|
template class DV_EXPORT_API tcg::Mesh<TTextureVertex, tcg::Edge, tcg::FaceN<3>>;
|
|
template class DV_EXPORT_API tcg::TriMesh<TTextureVertex, tcg::Edge, tcg::FaceN<3>>;
|
|
|
|
typedef tcg::TriMesh<TTextureVertex, tcg::Edge, tcg::FaceN<3>> TriMesh_base;
|
|
|
|
//******************************************************************************
|
|
// TTextureMesh implementation
|
|
//******************************************************************************
|
|
|
|
DEFINE_CLASS_CODE(TTextureMesh, 120)
|
|
PERSIST_IDENTIFIER(TTextureMesh, "mesh")
|
|
|
|
static TTextureMeshP cloneMesh_(const TTextureMeshP &other)
|
|
{
|
|
return TTextureMeshP(new TTextureMesh(*other));
|
|
}
|
|
|
|
void static_check()
|
|
{
|
|
/* input iterator */
|
|
static_assert(std::is_same<std::iterator_traits<std::vector<TTextureMesh>::iterator>::iterator_category, std::random_access_iterator_tag>::value == true, "random");
|
|
|
|
static_assert(std::is_base_of<std::input_iterator_tag, std::iterator_traits<std::vector<TTextureMesh>::iterator>::iterator_category>::value == true, "input");
|
|
|
|
static_assert(std::is_base_of<std::forward_iterator_tag, std::iterator_traits<std::vector<TTextureMesh>::iterator>::iterator_category>::value == true, "forward");
|
|
|
|
static_assert(std::is_constructible<TTextureMeshP,
|
|
std::iterator_traits<std::vector<TTextureMeshP>::iterator>::reference>::value == true,
|
|
"akan");
|
|
|
|
/* converted iterator */
|
|
std::vector<TTextureMeshP> vec;
|
|
auto it = vec.end();
|
|
auto c = tcg::make_cast_it(it, cloneMesh_);
|
|
|
|
static_assert(std::is_same<std::iterator_traits<decltype(c)>::iterator_category, std::random_access_iterator_tag>::value == true, "random");
|
|
|
|
static_assert(std::is_base_of<std::input_iterator_tag, std::iterator_traits<decltype(c)>::iterator_category>::value == true, "input");
|
|
|
|
static_assert(std::is_base_of<std::forward_iterator_tag, std::iterator_traits<decltype(c)>::iterator_category>::value == true, "forward");
|
|
|
|
//TTextureMeshP p(std::iterator_traits< decltype(c) >::reference);
|
|
static_assert(std::is_constructible<TTextureMeshP,
|
|
std::iterator_traits<decltype(c)>::reference>::value == true,
|
|
"akan");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TTextureMesh::TTextureMesh()
|
|
: TSmartObject(m_classCode)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TTextureMesh::TTextureMesh(const TTextureMesh &other)
|
|
: TriMesh_base(other), TSmartObject(m_classCode)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TTextureMesh &TTextureMesh::operator=(const TTextureMesh &other)
|
|
{
|
|
TriMesh_base::operator=(other);
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
bool TTextureMesh::faceContains(int f, const TPointD &p) const
|
|
{
|
|
int v0, v1, v2;
|
|
this->faceVertices(f, v0, v1, v2);
|
|
|
|
const TPointD &p0 = vertex(v0).P();
|
|
const TPointD &p1 = vertex(v1).P();
|
|
const TPointD &p2 = vertex(v2).P();
|
|
|
|
bool clockwise = (tcg::point_ops::cross(p2 - p0, p1 - p0) >= 0);
|
|
return ((tcg::point_ops::cross(p - p0, p1 - p0) >= 0) == clockwise) &&
|
|
((tcg::point_ops::cross(p - p1, p2 - p1) >= 0) == clockwise) &&
|
|
((tcg::point_ops::cross(p - p2, p0 - p2) >= 0) == clockwise);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
int TTextureMesh::faceContaining(const TPointD &p) const
|
|
{
|
|
int f, fCount = facesCount();
|
|
for (f = 0; f < fCount; ++f)
|
|
if (faceContains(f, p))
|
|
return f;
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TRectD TTextureMesh::getBBox() const
|
|
{
|
|
// TODO: Should be cached...
|
|
|
|
const double max = (std::numeric_limits<double>::max)();
|
|
TRectD result(max, max, -max, -max);
|
|
|
|
// Iterate all meshes
|
|
assert(m_vertices.size() == m_vertices.nodesCount());
|
|
|
|
int v, vCount = int(m_vertices.size());
|
|
for (v = 0; v != vCount; ++v) {
|
|
const TTextureVertex &vx = m_vertices[v];
|
|
|
|
result.x0 = tmin(result.x0, vx.P().x);
|
|
result.y0 = tmin(result.y0, vx.P().y);
|
|
result.x1 = tmax(result.x1, vx.P().x);
|
|
result.y1 = tmax(result.y1, vx.P().y);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void TTextureMesh::saveData(TOStream &os)
|
|
{
|
|
struct locals {
|
|
static inline bool hasNon1Rigidity(const TTextureMesh &mesh)
|
|
{
|
|
int v, vCount = int(mesh.verticesCount());
|
|
for (v = 0; v != vCount; ++v)
|
|
if (mesh.vertex(v).P().rigidity != 1.0)
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// NOTE: Primitives saved by INDEX iteration is NOT COINCIDENTAL - since
|
|
// the lists' internal linking could have been altered to mismatch the
|
|
// natural indexing referred to by primitives' data.
|
|
|
|
if (m_vertices.size() != m_vertices.nodesCount() ||
|
|
m_edges.size() != m_edges.nodesCount() ||
|
|
m_faces.size() != m_faces.nodesCount()) {
|
|
// Ensure the mesh is already squeezed - save a squeezed
|
|
// copy if necessary
|
|
TTextureMesh mesh(*this);
|
|
|
|
mesh.squeeze();
|
|
mesh.saveData(os);
|
|
|
|
return;
|
|
}
|
|
|
|
assert(m_vertices.size() == m_vertices.nodesCount());
|
|
assert(m_edges.size() == m_edges.nodesCount());
|
|
assert(m_faces.size() == m_faces.nodesCount());
|
|
|
|
// Store Vertices
|
|
os.openChild("V");
|
|
{
|
|
int vCount = int(m_vertices.size());
|
|
os << vCount;
|
|
|
|
for (int v = 0; v != vCount; ++v) {
|
|
TTextureMesh::vertex_type &vx = m_vertices[v];
|
|
os << vx.P().x << vx.P().y;
|
|
}
|
|
}
|
|
os.closeChild();
|
|
|
|
// Store Edges
|
|
os.openChild("E");
|
|
{
|
|
int eCount = int(m_edges.size());
|
|
os << eCount;
|
|
|
|
for (int e = 0; e != eCount; ++e) {
|
|
TTextureMesh::edge_type &ed = m_edges[e];
|
|
os << ed.vertex(0) << ed.vertex(1);
|
|
}
|
|
}
|
|
os.closeChild();
|
|
|
|
// Store Faces
|
|
os.openChild("F");
|
|
{
|
|
int fCount = int(m_faces.size());
|
|
os << fCount;
|
|
|
|
for (int f = 0; f != fCount; ++f) {
|
|
TTextureMesh::face_type &fc = m_faces[f];
|
|
|
|
int e, eCount = fc.edgesCount();
|
|
for (e = 0; e < eCount; ++e)
|
|
os << fc.edge(e);
|
|
}
|
|
}
|
|
os.closeChild();
|
|
|
|
// Store rigidities
|
|
if (locals::hasNon1Rigidity(*this)) {
|
|
os.openChild("rigidities");
|
|
{
|
|
int vCount = int(m_vertices.size());
|
|
os << vCount;
|
|
|
|
for (int v = 0; v != vCount; ++v)
|
|
os << m_vertices[v].P().rigidity;
|
|
}
|
|
os.closeChild();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void TTextureMesh::loadData(TIStream &is)
|
|
{
|
|
typedef tcg::Mesh<vertex_type, edge_type, face_type> mesh_type;
|
|
|
|
std::string str;
|
|
int i, size;
|
|
|
|
while (is.openChild(str)) {
|
|
if (str == "V") {
|
|
is >> size;
|
|
|
|
m_vertices.reserve(size);
|
|
TTextureMesh::vertex_type v;
|
|
|
|
for (i = 0; i < size; ++i) {
|
|
is >> v.P().x >> v.P().y;
|
|
mesh_type::addVertex(v);
|
|
}
|
|
|
|
is.closeChild();
|
|
} else if (str == "E") {
|
|
is >> size;
|
|
|
|
m_edges.reserve(size);
|
|
int v0, v1;
|
|
|
|
for (i = 0; i < size; ++i) {
|
|
is >> v0 >> v1;
|
|
mesh_type::addEdge(TTextureMesh::edge_type(v0, v1));
|
|
}
|
|
|
|
is.closeChild();
|
|
} else if (str == "F") {
|
|
is >> size;
|
|
|
|
m_faces.reserve(size);
|
|
|
|
int e[3];
|
|
|
|
for (i = 0; i < size; ++i) {
|
|
is >> e[0] >> e[1] >> e[2];
|
|
mesh_type::addFace(TTextureMesh::face_type(e));
|
|
}
|
|
|
|
is.closeChild();
|
|
} else if (str == "rigidities") {
|
|
is >> size;
|
|
size = tmin(size, this->verticesCount());
|
|
|
|
for (i = 0; i < size; ++i)
|
|
is >> m_vertices[i].P().rigidity;
|
|
|
|
is.closeChild();
|
|
} else {
|
|
assert(false);
|
|
is.skipCurrentTag();
|
|
}
|
|
}
|
|
}
|
|
|
|
//******************************************************************************
|
|
// TMeshImage::Imp definition
|
|
//******************************************************************************
|
|
|
|
class TMeshImage::Imp
|
|
{
|
|
public:
|
|
std::vector<TTextureMeshP> m_meshes; //!< Mesh data
|
|
double m_dpiX, m_dpiY; //!< Meshes dpi
|
|
|
|
Imp() : m_dpiX(), m_dpiY() {}
|
|
|
|
Imp(const Imp &other)
|
|
: m_meshes(tcg::make_cast_it(other.m_meshes.begin(), cloneMesh),
|
|
tcg::make_cast_it(other.m_meshes.end(), cloneMesh)),
|
|
m_dpiX(other.m_dpiX), m_dpiY(other.m_dpiY) {}
|
|
|
|
private:
|
|
static TTextureMeshP cloneMesh(const TTextureMeshP &other)
|
|
{
|
|
return TTextureMeshP(new TTextureMesh(*other));
|
|
}
|
|
|
|
// Not assignable
|
|
Imp &operator=(const Imp &other);
|
|
};
|
|
|
|
//******************************************************************************
|
|
// TMeshImage implementation
|
|
//******************************************************************************
|
|
|
|
TMeshImage::TMeshImage()
|
|
: m_imp(new Imp)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TMeshImage::TMeshImage(std::shared_ptr<Imp> imp)
|
|
: m_imp(std::move(imp))
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TMeshImage::~TMeshImage()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TMeshImage::TMeshImage(const TMeshImage &other)
|
|
: m_imp(new Imp(*other.m_imp))
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TMeshImage &TMeshImage::operator=(TMeshImage other)
|
|
{
|
|
swap(*this, other);
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TRectD TMeshImage::getBBox() const
|
|
{
|
|
const double max = (std::numeric_limits<double>::max)();
|
|
TRectD result(max, max, -max, -max);
|
|
|
|
// Iterate all meshes
|
|
int m, mCount = int(m_imp->m_meshes.size());
|
|
for (m = 0; m < mCount; ++m)
|
|
result += m_imp->m_meshes[m]->getBBox();
|
|
|
|
return result;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
TImage *TMeshImage::cloneImage() const
|
|
{
|
|
return new TMeshImage(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void TMeshImage::getDpi(double &dpix, double &dpiy) const
|
|
{
|
|
dpix = m_imp->m_dpiX, dpiy = m_imp->m_dpiY;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void TMeshImage::setDpi(double dpix, double dpiy)
|
|
{
|
|
m_imp->m_dpiX = dpix, m_imp->m_dpiY = dpiy;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
const std::vector<TTextureMeshP> &TMeshImage::meshes() const
|
|
{
|
|
return m_imp->m_meshes;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
std::vector<TTextureMeshP> &TMeshImage::meshes()
|
|
{
|
|
return m_imp->m_meshes;
|
|
}
|