mirror of
https://github.com/SoftFever/OrcaSlicer.git
synced 2025-10-24 09:11:23 -06:00
2ae2672ee9
Fixing dep build script on Windows and removing some warnings. Use bundled igl by default. Not building with the dependency scripts if not explicitly stated. This way, it will stay in Fix the libigl patch to include C source files in header only mode.
153 lines
No EOL
4.9 KiB
C++
153 lines
No EOL
4.9 KiB
C++
// This file is part of libigl, a simple c++ geometry processing library.
|
|
//
|
|
// Copyright (C) 2016 Qingan Zhou <qnzhou@gmail.com>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public License
|
|
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
|
|
// obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
#include "flip_edge.h"
|
|
|
|
template <
|
|
typename DerivedF,
|
|
typename DerivedE,
|
|
typename DeriveduE,
|
|
typename DerivedEMAP,
|
|
typename uE2EType>
|
|
IGL_INLINE void igl::flip_edge(
|
|
Eigen::PlainObjectBase<DerivedF> & F,
|
|
Eigen::PlainObjectBase<DerivedE> & E,
|
|
Eigen::PlainObjectBase<DeriveduE> & uE,
|
|
Eigen::PlainObjectBase<DerivedEMAP> & EMAP,
|
|
std::vector<std::vector<uE2EType> > & uE2E,
|
|
const size_t uei)
|
|
{
|
|
typedef typename DerivedF::Scalar Index;
|
|
const size_t num_faces = F.rows();
|
|
assert(F.cols() == 3);
|
|
// v1 v1
|
|
// /|\ / \
|
|
// / | \ /f1 \
|
|
// v3 /f2|f1\ v4 => v3 /_____\ v4
|
|
// \ | / \ f2 /
|
|
// \ | / \ /
|
|
// \|/ \ /
|
|
// v2 v2
|
|
auto& half_edges = uE2E[uei];
|
|
if (half_edges.size() != 2) {
|
|
throw "Cannot flip non-manifold or boundary edge";
|
|
}
|
|
|
|
const size_t f1 = half_edges[0] % num_faces;
|
|
const size_t f2 = half_edges[1] % num_faces;
|
|
const size_t c1 = half_edges[0] / num_faces;
|
|
const size_t c2 = half_edges[1] / num_faces;
|
|
assert(c1 < 3);
|
|
assert(c2 < 3);
|
|
|
|
assert(f1 != f2);
|
|
const size_t v1 = F(f1, (c1+1)%3);
|
|
const size_t v2 = F(f1, (c1+2)%3);
|
|
const size_t v4 = F(f1, c1);
|
|
const size_t v3 = F(f2, c2);
|
|
assert(F(f2, (c2+2)%3) == v1);
|
|
assert(F(f2, (c2+1)%3) == v2);
|
|
|
|
const size_t e_12 = half_edges[0];
|
|
const size_t e_24 = f1 + ((c1 + 1) % 3) * num_faces;
|
|
const size_t e_41 = f1 + ((c1 + 2) % 3) * num_faces;
|
|
const size_t e_21 = half_edges[1];
|
|
const size_t e_13 = f2 + ((c2 + 1) % 3) * num_faces;
|
|
const size_t e_32 = f2 + ((c2 + 2) % 3) * num_faces;
|
|
assert(E(e_12, 0) == v1);
|
|
assert(E(e_12, 1) == v2);
|
|
assert(E(e_24, 0) == v2);
|
|
assert(E(e_24, 1) == v4);
|
|
assert(E(e_41, 0) == v4);
|
|
assert(E(e_41, 1) == v1);
|
|
assert(E(e_21, 0) == v2);
|
|
assert(E(e_21, 1) == v1);
|
|
assert(E(e_13, 0) == v1);
|
|
assert(E(e_13, 1) == v3);
|
|
assert(E(e_32, 0) == v3);
|
|
assert(E(e_32, 1) == v2);
|
|
|
|
const size_t ue_24 = EMAP(e_24);
|
|
const size_t ue_41 = EMAP(e_41);
|
|
const size_t ue_13 = EMAP(e_13);
|
|
const size_t ue_32 = EMAP(e_32);
|
|
|
|
F(f1, 0) = v1;
|
|
F(f1, 1) = v3;
|
|
F(f1, 2) = v4;
|
|
F(f2, 0) = v2;
|
|
F(f2, 1) = v4;
|
|
F(f2, 2) = v3;
|
|
|
|
uE(uei, 0) = v3;
|
|
uE(uei, 1) = v4;
|
|
|
|
const size_t new_e_34 = f1;
|
|
const size_t new_e_41 = f1 + num_faces;
|
|
const size_t new_e_13 = f1 + num_faces*2;
|
|
const size_t new_e_43 = f2;
|
|
const size_t new_e_32 = f2 + num_faces;
|
|
const size_t new_e_24 = f2 + num_faces*2;
|
|
|
|
E(new_e_34, 0) = v3;
|
|
E(new_e_34, 1) = v4;
|
|
E(new_e_41, 0) = v4;
|
|
E(new_e_41, 1) = v1;
|
|
E(new_e_13, 0) = v1;
|
|
E(new_e_13, 1) = v3;
|
|
E(new_e_43, 0) = v4;
|
|
E(new_e_43, 1) = v3;
|
|
E(new_e_32, 0) = v3;
|
|
E(new_e_32, 1) = v2;
|
|
E(new_e_24, 0) = v2;
|
|
E(new_e_24, 1) = v4;
|
|
|
|
EMAP(new_e_34) = uei;
|
|
EMAP(new_e_43) = uei;
|
|
EMAP(new_e_41) = ue_41;
|
|
EMAP(new_e_13) = ue_13;
|
|
EMAP(new_e_32) = ue_32;
|
|
EMAP(new_e_24) = ue_24;
|
|
|
|
auto replace = [](std::vector<Index>& array, Index old_v, Index new_v) {
|
|
std::replace(array.begin(), array.end(), old_v, new_v);
|
|
};
|
|
replace(uE2E[uei], e_12, new_e_34);
|
|
replace(uE2E[uei], e_21, new_e_43);
|
|
replace(uE2E[ue_13], e_13, new_e_13);
|
|
replace(uE2E[ue_32], e_32, new_e_32);
|
|
replace(uE2E[ue_24], e_24, new_e_24);
|
|
replace(uE2E[ue_41], e_41, new_e_41);
|
|
|
|
#ifndef NDEBUG
|
|
auto sanity_check = [&](size_t ue) {
|
|
const auto& adj_faces = uE2E[ue];
|
|
if (adj_faces.size() == 2) {
|
|
const size_t first_f = adj_faces[0] % num_faces;
|
|
const size_t first_c = adj_faces[0] / num_faces;
|
|
const size_t second_f = adj_faces[1] % num_faces;
|
|
const size_t second_c = adj_faces[1] / num_faces;
|
|
const size_t vertex_0 = F(first_f, (first_c+1) % 3);
|
|
const size_t vertex_1 = F(first_f, (first_c+2) % 3);
|
|
assert(vertex_0 == F(second_f, (second_c+2) % 3));
|
|
assert(vertex_1 == F(second_f, (second_c+1) % 3));
|
|
}
|
|
};
|
|
|
|
sanity_check(uei);
|
|
sanity_check(ue_13);
|
|
sanity_check(ue_32);
|
|
sanity_check(ue_24);
|
|
sanity_check(ue_41);
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifdef IGL_STATIC_LIBRARY
|
|
template void igl::flip_edge<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, int>(Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >&, unsigned long);
|
|
#endif |