allemang.d/toddcox-visualize
1
0
Fork 0
mirror of https://github.com/allemangD/toddcox-visualize.git synced 2025-11-10 03:52:48 -05:00
Code Issues Packages Projects Releases Wiki Activity

OPT: Remove not-working parity logic for culling

Browse Source
This commit is contained in:
David Allemang
2023-01-26 16:19:36 -05:00
parent 6ef6fbf4ac
commit 486977f444
1 changed files with 30 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
vis/include/geometry.hpp
View File

@@ -28,15 +28,10 @@ struct Primitive {
~Primitive() = default;
inline void flip() {
if (N > 1) std::swap(inds[0], inds[1]);
}
void apply(const tc::Cosets<> &table, int gen) {
for (auto &ind: inds) {
ind = table.get(ind, gen);
}
flip();
}
};
@@ -51,15 +46,15 @@ std::vector<size_t> generators(const tc::Group<> &context) {
/**
* Determine which of g_gens are the correct names for sg_gens within the current context
*
* Produces the indexes of sg_gens within g_gens; sorted.
*/
std::vector<size_t> recontext_gens(
const tc::Group<> &context,
std::vector<size_t> g_gens,
std::vector<size_t> sg_gens) {
const std::vector<size_t> &g_gens,
const std::vector<size_t> &sg_gens) {
std::sort(g_gens.begin(), g_gens.end());
int inv_gen_map[context.rank()];
size_t inv_gen_map[context.rank()];
for (size_t i = 0; i < g_gens.size(); i++) {
inv_gen_map[g_gens[i]] = i;
}
@@ -69,45 +64,10 @@ std::vector<size_t> recontext_gens(
for (const auto gen : sg_gens) {
s_sg_gens.push_back(inv_gen_map[gen]);
}
std::sort(s_sg_gens.begin(), s_sg_gens.end());
return s_sg_gens;
}
/**
* Determine whether the orientation of the group sg_gens is reversed from the group g_gens within group context
*/
int get_parity(
const tc::Group<> &context,
const std::vector<size_t> &g_gens,
const std::vector<size_t> &sg_gens
) {
if (g_gens.size() != sg_gens.size() + 1) return 0;
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
int i = 0;
for (; i < sg_gens.size(); ++i) {
if (proper_sg_gens[i] != i) {
break;
}
}
return i & 1;
}
/**
* Solve the cosets generated by sg_gens within the subgroup generated by g_gens of the group context
*/
tc::Cosets<> solve(
const tc::Group<> &context,
const std::vector<size_t> &g_gens,
const std::vector<size_t> &sg_gens
) {
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
return context.sub(g_gens).solve(proper_sg_gens);
}
/**
* Apply some context transformation to all primitives of this mesh.
*/
@@ -119,16 +79,6 @@ std::vector<Primitive<N>> apply(std::vector<Primitive<N>> prims, const tc::Coset
return prims;
}
/**
* Reverse the orientation of all primitives in this mesh.
*/
template<unsigned N>
void flip(std::vector<Primitive<N>> prims) {
for (auto &prim : prims) {
prim.flip();
}
}
/**
* Convert the indexes of this mesh to those of a different context, using g_gens to build the parent context and sg_gens to build this context.
*/
@@ -141,26 +91,23 @@ std::vector<Primitive<N>> recontext(
const std::vector<size_t> &sg_gens
) {
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
const auto table = solve(context, g_gens, {});
const auto &cosets = solve(context, sg_gens, {});
const auto table = context.sub(g_gens).solve({});
const auto cosets = context.sub(sg_gens).solve({});
tc::Path<size_t> path(cosets, proper_sg_gens);
std::vector<size_t> map(path.order());
path.walk(0, [&table](size_t coset, size_t gen){
path.walk(0, [&table](size_t coset, size_t gen) {
return table.get(coset, gen);
}, map.begin());
std::vector<Primitive<N>> res(prims);
for (Primitive<N> &prim : res) {
for (auto &ind : prim.inds) {
for (Primitive<N> &prim: res) {
for (auto &ind: prim.inds) {
ind = map[ind];
}
}
if (get_parity(context, g_gens, sg_gens) == 1)
flip(res);
return res;
}
@@ -194,10 +141,11 @@ std::vector<std::vector<Primitive<N>>> each_tile(
std::vector<Primitive<N>> base = recontext(prims, context, g_gens, sg_gens);
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
const auto table = solve(context, g_gens, {});
tc::Path path(solve(context, g_gens, sg_gens));
const auto table = context.sub(g_gens).solve({});
auto _gens = generators(context);
const tc::Cosets<> &cosets = context.sub(g_gens).solve(proper_sg_gens);
tc::Path path(cosets);
std::vector<std::vector<Primitive<N>>> res(path.order());
path.walk(base, [&](auto from, auto to) {
@@ -227,7 +175,9 @@ template<unsigned N>
[[nodiscard]]
std::vector<Primitive<N + 1>> fan(std::vector<Primitive<N>> prims, size_t root) {
std::vector<Primitive<N + 1>> res(prims.size());
std::transform(prims.begin(), prims.end(), res.begin(),
std::transform(
prims.begin(), prims.end(),
res.begin(),
[root](const Primitive<N> &prim) {
return Primitive<N + 1>(prim, root);
}
@@ -243,14 +193,15 @@ std::vector<Primitive<N>> triangulate(
const tc::Group<> &context,
const std::vector<size_t> &g_gens
) {
if (g_gens.size() + 1 != N) // todo make static assert
if (g_gens.size() + 1 != N) {
throw std::logic_error("g_gens size must be one less than N");
}
const auto &combos = Combos(g_gens, g_gens.size() - 1);
const auto &combos = Combos<size_t>(g_gens, g_gens.size() - 1U);
std::vector<std::vector<Primitive<N>>> meshes;
for (const auto &sg_gens : combos) {
for (const auto &sg_gens: combos) {
auto base = triangulate<N - 1>(context, sg_gens);
auto raised = tile(base, context, g_gens, sg_gens);
raised.erase(raised.begin(), raised.begin() + base.size());
@@ -260,16 +211,15 @@ std::vector<Primitive<N>> triangulate(
return merge(meshes);
}
/**
* Single-index primitives should not be further triangulated.
*/
// Single-index primitives should not be further triangulated.
template<>
std::vector<Primitive<1>> triangulate(
const tc::Group<> &context,
const tc::Group<> &,
const std::vector<size_t> &g_gens
) {
if (not g_gens.empty()) // todo make static assert
if (not g_gens.empty()) {
throw std::logic_error("g_gens must be empty for a trivial Mesh");
}
std::vector<Primitive<1>> res;
res.emplace_back();
@@ -279,7 +229,9 @@ std::vector<Primitive<1>> triangulate(
template<unsigned N, class T>
auto hull(const tc::Group<> &group, T all_sg_gens, const std::vector<std::vector<size_t>> &exclude) {
std::vector<std::vector<Primitive<N>>> parts;
auto g_gens = generators(group);
for (std::vector<size_t> sg_gens: all_sg_gens) {
bool excluded = false;
for (const auto &test: exclude) {