djledda/somaesque-native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

finally all working

Browse Source
This commit is contained in:
Daniel Ledda
2022-12-27 06:24:36 +01:00
parent bd52c9a93f
commit 82906bd3de
6 changed files with 501 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@@ -1 +1,4 @@
/build
/emcc_build
/debug
.vscode

12
CMakeLists.txt
View File

@@ -1,10 +1,14 @@
cmake_minimum_required(VERSION 3.18)
cmake_minimum_required(VERSION 3.24)
project(somaesque)
set(CMAKE_BUILD_TYPE Release)
set(CMAKE_CXX_FLAGS_RELEASE "-O3")
#find_package(glfw3 3.3 REQUIRED)
#find_package(glm REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_FLAGS -I/usr/include/SDL2)
set(CMAKE_CXX_STANDARD 20)
#set(CMAKE_CXX_FLAGS -I/usr/include/SDL2)
add_executable(somaesque
main.cpp
@@ -32,7 +36,7 @@ add_executable(tests
target_link_libraries(
tests
GTest::gtest_main
)
)
include(GoogleTest)
gtest_discover_tests(tests)

190
VoxelSpace.cpp
View File

@@ -1,46 +1,48 @@
#include "VoxelSpace.h"
#include <vector>
#include <bitset>
#include <algorithm>
#include <iostream>
#include <cstdint>
#include "VoxelSpace.h"
namespace Voxel {
inline auto index(int dims[3], int x, int y, int z) -> int {
return (dims[1] * dims[2] * x + dims[2] * y + z);
auto index(int dim_y, int dim_z, int x, int y, int z) -> int {
return dim_y * dim_z * x + dim_z * y + z;
}
// [1, 0, 0] [x] [ x]
// [0, 0, -1] * [y] = [-z]
// [0, 1, 0] [z] [ y]
inline auto newIndexRotX(int dims[3], int x, int y, int z) -> int {
return dims[2] * dims[1] * x + dims[1] * (dims[2] - 1 - z) + y;
auto newIndexRotX(Space *space, int x, int y, int z) -> int {
return space->dim_z * space->dim_y * x + space->dim_y * (space->dim_z - 1 - z) + y;
}
// [ 0, 0, 1] [x] [ z]
// [ 0, 1, 0] * [y] = [ y]
// [-1, 0, 0] [z] [-x]
inline auto newIndexRotY(int dims[3], int x, int y, int z) -> int {
return dims[1] * dims[0] * z + dims[0] * y + (dims[0] - 1 - x);
auto newIndexRotY(Space *space, int x, int y, int z) -> int {
return space->dim_y * space->dim_x * z + space->dim_x * y + (space->dim_x - 1 - x);
}
// [0, -1, 0] [x] [-y]
// [1, 0, 0] * [y] = [ x]
// [0, 0, 1] [z] [ z]
inline auto newIndexRotZ(int dims[3], int x, int y, int z) -> int {
return dims[0] * dims[2] * (dims[1] - 1 - y) + dims[2] * x + z;
auto newIndexRotZ(Space *space, int x, int y, int z) -> int {
return space->dim_x * space->dim_z * (space->dim_y - 1 - y) + space->dim_z * x + z;
}
inline auto toggle(uint64_t space, int index) -> uint64_t {
space ^= 1ull << index;
auto toggle(uint64_t space, int index) -> uint64_t {
space ^= 1ul << index;
return space;
}
inline auto set(uint64_t *space, int index, bool val) -> void {
auto set(uint64_t space, int index, bool val) -> uint64_t {
if (val) {
*space |= 1ull << index;
space |= 1ul << index;
} else {
*space &= ~(1ull << index);
space &= ~(1ul << index);
}
return space;
}
auto collides(uint64_t a, uint64_t b) -> bool {
@@ -51,25 +53,25 @@ namespace Voxel {
return (a->space | b->space) != (a->space ^ b->space);
}
inline auto filledAt(uint64_t space, int dims[3], int x, int y, int z) -> bool {
auto mask = 1ull << (dims[1] * dims[2] * x + dims[2] * y + z);
return (space & mask) != 0ull;
auto filledAt(Space *space, int x, int y, int z) -> bool {
auto mask = 1ul << (space->dim_y * space->dim_z * x + space->dim_z * y + z);
return (space->space & mask) != 0ul;
}
auto getExtrema(uint64_t space, int dims[3]) -> Extrema {
auto getExtrema(Space *space) -> Extrema {
auto extrema = Extrema{
.xMax=0,
.xMin=dims[0],
.xMin=space->dim_x,
.yMax=0,
.yMin=dims[1],
.yMin=space->dim_y,
.zMax=0,
.zMin=dims[2],
.zMin=space->dim_z,
};
for (int x = 0; x < dims[0]; x++) {
for (int y = 0; y < dims[1]; y++) {
for (int z = 0; z < dims[2]; z++) {
if (filledAt(space, dims, x, y, z)) {
for (int x = 0; x < space->dim_x; x++) {
for (int y = 0; y < space->dim_y; y++) {
for (int z = 0; z < space->dim_z; z++) {
if (filledAt(space, x, y, z)) {
if (x > extrema.xMax) extrema.xMax = x;
if (x < extrema.xMin) extrema.xMin = x;
if (y > extrema.yMax) extrema.yMax = y;
@@ -85,81 +87,81 @@ namespace Voxel {
}
auto cullEmptySpace(Space *space) -> void {
auto extrema = getExtrema(space->space, space->dims);
auto extrema = getExtrema(space);
auto space_index = 0;
auto newSpace = 0ull;
auto newSpace = 0ul;
for (int x = extrema.xMin; x <= extrema.xMax; x++) {
for (int y = extrema.yMin; y <= extrema.yMax; y++) {
for (int z = extrema.zMin; z <= extrema.zMax; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
newSpace |= 1ull << space_index;
if (filledAt(space, x, y, z)) {
newSpace |= 1ul << space_index;
}
space_index++;
}
}
}
space->dims[0] = extrema.xMax - extrema.xMin + 1;
space->dims[1] = extrema.yMax - extrema.yMin + 1;
space->dims[2] = extrema.zMax - extrema.zMin + 1;
space->dim_x = extrema.xMax - extrema.xMin + 1;
space->dim_y = extrema.yMax - extrema.yMin + 1;
space->dim_z = extrema.zMax - extrema.zMin + 1;
space->space = newSpace;
}
auto rotate90X(Space *space) -> void {
auto new_space = 0ull;
for (int x = 0; x < space->dims[0]; x++) {
for (int y = 0; y < space->dims[1]; y++) {
for (int z = 0; z < space->dims[2]; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
new_space |= 1 << newIndexRotX(space->dims, x, y, z);
auto new_space = 0ul;
for (int x = 0; x < space->dim_x; x++) {
for (int y = 0; y < space->dim_y; y++) {
for (int z = 0; z < space->dim_z; z++) {
if (filledAt(space, x, y, z)) {
new_space |= 1 << newIndexRotX(space, x, y, z);
}
}
}
}
auto temp = space->dims[1];
space->dims[1] = space->dims[2];
space->dims[2] = temp;
auto temp = space->dim_y;
space->dim_y = space->dim_z;
space->dim_z = temp;
space->space = new_space;
}
auto rotate90Y(Space *space) -> void {
auto new_space = 0ull;
for (int x = 0; x < space->dims[0]; x++) {
for (int y = 0; y < space->dims[1]; y++) {
for (int z = 0; z < space->dims[2]; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
new_space |= 1 << newIndexRotY(space->dims, x, y, z);
auto new_space = 0ul;
for (int x = 0; x < space->dim_x; x++) {
for (int y = 0; y < space->dim_y; y++) {
for (int z = 0; z < space->dim_z; z++) {
if (filledAt(space, x, y, z)) {
new_space |= 1 << newIndexRotY(space, x, y, z);
}
}
}
}
auto temp = space->dims[0];
space->dims[0] = space->dims[2];
space->dims[2] = temp;
auto temp = space->dim_x;
space->dim_x = space->dim_z;
space->dim_z = temp;
space->space = new_space;
}
auto rotate90Z(Space *space) -> void {
auto new_space = 0ull;
for (int x = 0; x < space->dims[0]; x++) {
for (int y = 0; y < space->dims[1]; y++) {
for (int z = 0; z < space->dims[2]; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
new_space |= 1 << newIndexRotZ(space->dims, x, y, z);
auto new_space = 0ul;
for (int x = 0; x < space->dim_x; x++) {
for (int y = 0; y < space->dim_y; y++) {
for (int z = 0; z < space->dim_z; z++) {
if (filledAt(space, x, y, z)) {
new_space |= 1 << newIndexRotZ(space, x, y, z);
}
}
}
}
auto temp = space->dims[0];
space->dims[0] = space->dims[1];
space->dims[1] = temp;
auto temp = space->dim_x;
space->dim_x = space->dim_y;
space->dim_y = temp;
space->space = new_space;
}
inline auto isMatch(Space *a, Space *b) -> bool {
auto isMatch(Space *a, Space *b) -> bool {
return a->space == b->space
&& a->dims[0] == b->dims[0]
&& a->dims[1] == b->dims[1]
&& a->dims[2] == b->dims[2];
&& a->dim_x == b->dim_x
&& a->dim_y == b->dim_y
&& a->dim_z == b->dim_z;
}
auto pushNewUniqueSpins(std::vector<Space> *existingSpaces, Space* spaceToSpin) -> void {
@@ -185,7 +187,7 @@ namespace Voxel {
auto pushXAxisSpins(std::vector<Space> *existingSpaces, Space* spaceToSpin) -> void {
auto refSpace = *spaceToSpin;
for (int i = 0; i < 3; i++) {
for (int i = 0; i < 4; i++) {
rotate90X(&refSpace);
existingSpaces->push_back(refSpace);
}
@@ -193,30 +195,14 @@ namespace Voxel {
auto getUniqueRotations(Space *space) -> std::vector<Space> {
auto rotations = std::vector<Space>();
rotations.reserve(6*24);
auto dims = space->dims;
rotations.reserve(24);
auto refSpace = *space;
cullEmptySpace(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Z(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Z(&refSpace);
rotate90Z(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
return rotations;
}
auto getUniqueRotations(Space *space) -> std::vector<Space> {
auto rotations = std::vector<Space>();
rotations.reserve(6*24);
auto dims = space->dims;
auto refSpace = *space;
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Z(&refSpace);
@@ -229,41 +215,41 @@ namespace Voxel {
auto getAllRotations(Space *space) -> std::vector<Space> {
auto rotations = std::vector<Space>();
rotations.reserve(6*24);
auto dims = space->dims;
rotations.reserve(24);
auto refSpace = *space;
pushXAxisSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushXAxisSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
pushXAxisSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushXAxisSpins(&rotations, &refSpace);
rotate90Z(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
pushXAxisSpins(&rotations, &refSpace);
rotate90Z(&refSpace);
rotate90Z(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
pushXAxisSpins(&rotations, &refSpace);
return rotations;
}
auto getAllPositionsInPrism(uint64_t space, int space_dims[3], int prism_dims[3]) -> std::vector<uint64_t> {
auto getAllPositionsInPrism(Space *space, int prism_dims[3]) -> std::vector<uint64_t> {
auto cubePositions = std::vector<uint64_t>();
if (space_dims[0] > prism_dims[0] || space_dims[1] > prism_dims[1] || space_dims[2] > prism_dims[2]) {
if (space->dim_x > prism_dims[0] || space->dim_y > prism_dims[1] || space->dim_z > prism_dims[2]) {
return cubePositions;
}
auto xPositionCount = prism_dims[0] - space_dims[0] + 1;
auto yPositionCount = prism_dims[1] - space_dims[1] + 1;
auto zPositionCount = prism_dims[2] - space_dims[2] + 1;
cubePositions.reserve(xPositionCount + yPositionCount + zPositionCount);
auto xPositionCount = prism_dims[0] - space->dim_x + 1;
auto yPositionCount = prism_dims[1] - space->dim_y + 1;
auto zPositionCount = prism_dims[2] - space->dim_z + 1;
for (int x = 0; x < xPositionCount; x++) {
for (int y = 0; y < yPositionCount; y++) {
for (int z = 0; z < zPositionCount; z++) {
auto new_space = space;
for (int posX = 0; posX < space_dims[0]; posX++) {
for (int posY = 0; posY < space_dims[1]; posY++) {
for (int posZ = 0; posZ < space_dims[2]; posZ++) {
auto set_val = filledAt(space, space_dims, x, y, z);
auto index_to_set = index(space_dims, x + posX, y + posY, z + posZ);
set(&new_space, index_to_set, set_val);
auto new_space = 0ul;
for (int posX = 0; posX < space->dim_x; posX++) {
for (int posY = 0; posY < space->dim_y; posY++) {
for (int posZ = 0; posZ < space->dim_z; posZ++) {
auto set_val = filledAt(space, posX, posY, posZ);
auto index_to_set = index(prism_dims[1], prism_dims[2], x + posX, y + posY, z + posZ);
new_space = set(new_space, index_to_set, set_val);
}
}
}
@@ -278,7 +264,7 @@ namespace Voxel {
auto rotations = getUniqueRotations(space);
auto result = std::vector<uint64_t>();
for (auto &rotation : rotations) {
auto positions = getAllPositionsInPrism(rotation.space, rotation.dims, prism_dims);
auto positions = getAllPositionsInPrism(&rotation, prism_dims);
result.insert(result.end(), positions.begin(), positions.end());
}
return result;
@@ -287,7 +273,7 @@ namespace Voxel {
auto size(uint64_t space) -> int {
auto size = 0;
for (int i = 0; i < 64; i++) {
if ((space & (1ull << i)) != 0) {
if ((space & (1ul << i)) != 0) {
size++;
}
}

22
VoxelSpace.h
View File

@@ -5,6 +5,8 @@
#include <cstdint>
namespace Voxel {
constexpr int NUM_ROTS_3D = 24;
struct Extrema {
int xMax;
int xMin;
@@ -16,16 +18,16 @@ namespace Voxel {
struct Space {
uint64_t space;
int dims[3];
int dim_x;
int dim_y;
int dim_z;
};
auto index(int dims[3], int x, int y, int z) -> int;
auto newIndexRotX(int dims[3], int x, int y, int z) -> int;
auto newIndexRotX(Space *space, int x, int y, int z) -> int;
auto newIndexRotY(int dims[3], int x, int y, int z) -> int;
auto newIndexRotY(Space *space, int x, int y, int z) -> int;
auto newIndexRotZ(int dims[3], int x, int y, int z) -> int;
auto newIndexRotZ(Space *space, int x, int y, int z) -> int;
auto toggle(uint64_t space, int index) -> uint64_t;
@@ -36,9 +38,9 @@ namespace Voxel {
auto add(Space *a, Space *b) -> Space;
auto filledAt(uint64_t space, int dims[3], int x, int y, int z) -> bool;
auto filledAt(Space *space, int x, int y, int z) -> bool;
auto getExtrema(uint64_t space, int dims[3]) -> Extrema;
auto getExtrema(Space *space) -> Extrema;
auto cullEmptySpace(Space *space) -> void;
@@ -54,7 +56,9 @@ namespace Voxel {
auto getUniqueRotations(Space *space) -> std::vector<Space>;
auto getAllPositionsInPrism(uint64_t space, int space_dims[3], int prism_dims[3]) -> std::vector<uint64_t>;
auto getAllRotations(Space *space) -> std::vector<Space>;
auto getAllPositionsInPrism(Space *space, int prism_dims[3]) -> std::vector<uint64_t>;
auto getAllPermutationsInPrism(Space *space, int prism_dims[3]) -> std::vector<uint64_t>;

147
main.cpp
View File

@@ -1,4 +1,5 @@
#include <bitset>
#include <span>
#include <cstdint>
#include <iostream>
#include <string>
@@ -6,6 +7,14 @@
#include <vector>
#include "VoxelSpace.h"
using SomaSolution = std::vector<uint64_t>;
struct Solver {
std::vector<uint64_t>* input;
std::vector<int>* offsets;
std::vector<SomaSolution>* solutions;
};
auto backtrack_solve_iter(std::vector<uint64_t> *polycube_input, std::vector<int> *offsets)-> void {
auto num_inputs = offsets->size() - 1;
@@ -14,7 +23,7 @@ auto backtrack_solve_iter(std::vector<uint64_t> *polycube_input, std::vector<int
auto iter_stack = std::vector<int>();
auto curr_soln_stack = std::vector<int>();
auto soln_spaces_stack = std::vector<uint64_t>();
soln_spaces_stack.push_back(0ull);
soln_spaces_stack.push_back(0ul);
auto depth = 0;
@@ -54,47 +63,76 @@ auto backtrack_solve_iter(std::vector<uint64_t> *polycube_input, std::vector<int
std::cout << "Done. Found " << solns.size() << " solutions." << std::endl;
}
auto backtrack_solve(std::vector<uint64_t> *polycube_input, std::vector<int> *offsets, uint64_t working_solution = 0ull, int set = 0) -> int {
auto solns = 0;
auto start = offsets->at(set);
auto end = offsets->at(set + 1);
auto backtrack_solve(Solver *solver, uint64_t working_solution = 0ul, int curr_piece = 0) -> void {
auto input = solver->input;
auto offsets = solver->offsets;
auto solutions = solver->solutions;
auto start = offsets->at(curr_piece);
auto end = offsets->at(curr_piece + 1);
auto num_pieces = offsets->size() - 1;
for (int i = start; i < end; i++) {
auto successful_fuse = !Voxel::collides(working_solution, polycube_input->at(i));
auto successful_fuse = !Voxel::collides(working_solution, input->at(i));
if (successful_fuse) {
working_solution = working_solution | polycube_input->at(i);
if (set == offsets->size() - 2) {
return solns + 1;
auto new_working_solution = working_solution | input->at(i);
solutions->back().at(curr_piece) = input->at(i);
if (curr_piece == num_pieces - 1) {
auto last_soln = solutions->back();
solutions->push_back(SomaSolution(last_soln.begin(), last_soln.end()));
return;
} else {
solns += backtrack_solve(polycube_input, offsets, working_solution, set + 1);
backtrack_solve(solver, new_working_solution, curr_piece + 1);
}
}
}
return solns;
if (curr_piece == 0) {
solutions->pop_back();
}
}
auto filter_unique(std::vector<std::vector<uint64_t>> *solutions, int dims[3]) -> std::vector<std::vector<uint64_t>> {
if (solutions->size() == 0) {
return std::vector<std::vector<uint64_t>>();
}
auto unique_solns = std::vector<std::vector<uint64_t>>();
for (auto &solution : unique_solns) {
auto foundMatch = false;
auto soln_rotations = std::vector<std::vector<uint64_t>>();
for (auto &piece : solution) {
auto space = Voxel::Space{ .space=solution.at(0), .dims={ dims[0], dims[1], dims[2] } };
auto unique_rots = Voxel::getUniqueRotations(&space);
soln_rotations.insert(soln_rotations.end(), unique_rots.begin(), unique_rots.end());
auto get_solution_rotations(SomaSolution *solution, int dims[3]) -> std::vector<SomaSolution> {
auto result = std::vector<SomaSolution>(Voxel::NUM_ROTS_3D);
for (int piece_i = 0; piece_i < solution->size(); piece_i++) {
auto space = Voxel::Space{
.space=solution->at(piece_i),
.dim_x=dims[0],
.dim_y=dims[1],
.dim_z=dims[2],
};
auto piece_rotations = Voxel::getAllRotations(&space);
for (int rot_i = 0; rot_i < piece_rotations.size(); rot_i++) {
result[rot_i].push_back(piece_rotations[rot_i].space);
}
for (auto &rotation : soln_rotations) {
auto end = unique_solns.size();
for (int i = 0; i < end; i++) {
if (rotation == unique_solns[i]) {
foundMatch = true;
}
return result;
}
auto filter_unique(std::vector<SomaSolution> *solutions, int dims[3]) -> std::vector<SomaSolution> {
if (solutions->size() == 0) {
return std::vector<SomaSolution>();
}
auto unique_solns = std::vector<SomaSolution>{};
for (auto &solution : *solutions) {
auto found_match = false;
for (auto &rotation : get_solution_rotations(&solution, dims)) {
for (auto &unique_soln : unique_solns) {
auto is_match = true;
for (int piece_i = 0; piece_i < unique_soln.size(); piece_i++) {
if (rotation[piece_i] != unique_soln[piece_i]) {
is_match = false;
break;
}
}
if (is_match) {
found_match = true;
break;
}
}
if (found_match) {
break;
}
}
if (!foundMatch) {
unique_solns.push_back(solution);
if (!found_match) {
unique_solns.push_back(SomaSolution(solution));
}
}
return unique_solns;
@@ -137,12 +175,12 @@ auto get_reprs_input(int units_required) -> std::vector<uint64_t> {
continue;
}
}
auto bit_repr = 0ull;
auto bit_repr = 0ul;
auto i = 0;
auto good_repr = true;
for (auto it = input.rbegin(); it < input.rend(); it++, i++) {
if (*it == '1') {
bit_repr |= 1ull << i;
bit_repr |= 1ul << i;
total_units++;
} else if (*it != '0' || i >= 64) {
std::cout << "Input invalid. Enter a binary string only with max 64 bits." << '\n';
@@ -158,35 +196,39 @@ auto get_reprs_input(int units_required) -> std::vector<uint64_t> {
}
auto main() -> int {
int dims[3] = { 3, 3, 3 };
//get_dims_input(dims);
int dims[3];
get_dims_input(dims);
std::cout << '\n';
//auto reprs = get_reprs_input(dims[0]*dims[1]*dims[2]);
auto reprs = get_reprs_input(dims[0]*dims[1]*dims[2]);
/*
auto reprs = std::vector<uint64_t>{
23ull,
30ull,
15ull,
43ull,
172ull,
92ull,
11ull,
23ul,
30ul,
15ul,
1043ul,
24594ul,
12306ul,
11ul,
};
*/
std::cout << "Great. Calculating solutions...\n";
auto offsets = std::vector<int>();
auto polycubes = std::vector<uint64_t>();
polycubes.reserve(reprs.size() * 10);
auto model_space = Voxel::Space{
auto model_space = Voxel::Space{
.space={},
.dims={dims[0], dims[1], dims[2]},
.dim_x=dims[0],
.dim_y=dims[1],
.dim_z=dims[2],
};
offsets.push_back(polycubes.size());
offsets.push_back(0);
auto space = model_space;
space.space = reprs[0];
Voxel::cullEmptySpace(&space);
auto positions = Voxel::getAllPositionsInPrism(space.space, space.dims, dims);
auto positions = Voxel::getAllPositionsInPrism(&space, dims);
polycubes.insert(polycubes.end(), positions.begin(), positions.end());
for (int i = 1; i < reprs.size(); i++) {
@@ -200,8 +242,17 @@ auto main() -> int {
offsets.push_back(polycubes.size());
auto solns = backtrack_solve(&polycubes, &offsets);
auto solutions = std::vector<SomaSolution>{std::vector<uint64_t>(reprs.size())};
auto solver = Solver{
.input=&polycubes,
.offsets=&offsets,
.solutions=&solutions,
};
std::cout << solns << std::endl;
backtrack_solve(&solver);
auto filtered_solns = filter_unique(solver.solutions, dims);
std::cout << filtered_solns.size() << std::endl;
return 0;
}

331
tests.cpp
View File

@@ -1,63 +1,312 @@
#include <gtest/gtest.h>
#include <istream>
#include <tuple>
#include "VoxelSpace.h"
TEST(VoxelSpaces, BasicPositions) {
auto space = Voxel::Space{ .space=23ull, .dims={3, 3, 3}};
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 0), true);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 2, 1), false);
auto space = Voxel::Space{
.space=23ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(&space, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(&space, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(&space, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 0), true);
EXPECT_EQ(Voxel::filledAt(&space, 2, 2, 1), false);
space = Voxel::Space{ .space=30ull, .dims={3, 3, 3}};
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 2, 1), false);
space.space = 30ul;
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(&space, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(&space, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(&space, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(&space, 2, 2, 1), false);
space = Voxel::Space{ .space=15ull, .dims={3, 3, 3}};
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 0), true);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 2, 1), false);
space.space = 15ul;
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(&space, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(&space, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(&space, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 0), true);
EXPECT_EQ(Voxel::filledAt(&space, 2, 2, 1), false);
space = Voxel::Space{ .space=23ull, .dims={3, 3, 3}};
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 0, 0, 0), true);
EXPECT_EQ(Voxel::filledAt(space.space, space.dims, 2, 2, 1), false);
space.space = 23ul;
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 1), true);
EXPECT_EQ(Voxel::filledAt(&space, 1, 0, 0), false);
EXPECT_EQ(Voxel::filledAt(&space, 2, 1, 2), false);
EXPECT_EQ(Voxel::filledAt(&space, 1, 2, 1), false);
EXPECT_EQ(Voxel::filledAt(&space, 0, 0, 0), true);
EXPECT_EQ(Voxel::filledAt(&space, 2, 2, 1), false);
}
TEST(VoxelSpaces, RotatedIndices) {
auto space1 = Voxel::Space{ .space=172ull, .dims={3, 3, 3}};
auto space1 = Voxel::Space{
.space=172ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
EXPECT_EQ(Voxel::newIndexRotX(space1.dims, 0, 0, 0), 6);
EXPECT_EQ(Voxel::newIndexRotX(space1.dims, 1, 0, 1), 12);
EXPECT_EQ(Voxel::newIndexRotX(&space1, 0, 0, 0), 6);
EXPECT_EQ(Voxel::newIndexRotX(&space1, 1, 0, 1), 12);
EXPECT_EQ(Voxel::newIndexRotY(space1.dims, 0, 1, 0), 5);
EXPECT_EQ(Voxel::newIndexRotY(space1.dims, 1, 2, 0), 7);
EXPECT_EQ(Voxel::newIndexRotY(&space1, 0, 1, 0), 5);
EXPECT_EQ(Voxel::newIndexRotY(&space1, 1, 2, 0), 7);
EXPECT_EQ(Voxel::newIndexRotZ(space1.dims, 1, 0, 2), 23);
EXPECT_EQ(Voxel::newIndexRotZ(space1.dims, 0, 0, 0), 18);
EXPECT_EQ(Voxel::newIndexRotZ(&space1, 1, 0, 2), 23);
EXPECT_EQ(Voxel::newIndexRotZ(&space1, 0, 0, 0), 18);
}
TEST(VoxelSpaces, UniqueRotations) {
auto space1 = Voxel::Space{
.space=30ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
auto rotations = Voxel::getUniqueRotations(&space1);
auto expected_rots = std::vector<Voxel::Space>{
{ 30ul, 1, 2, 3 },
{ 45ul, 1, 3, 2 },
{ 30ul, 3, 2, 1 },
{ 30ul, 3, 1, 2 },
{ 45ul, 3, 2, 1 },
{ 45ul, 3, 1, 2 },
{ 51ul, 1, 2, 3 },
{ 30ul, 1, 3, 2 },
{ 30ul, 2, 3, 1 },
{ 30ul, 2, 1, 3 },
{ 51ul, 2, 3, 1 },
{ 51ul, 2, 1, 3 },
};
ASSERT_EQ(expected_rots.size(), rotations.size());
for (int i = 0; i < rotations.size(); i++) {
if (i <= expected_rots.size()) {
EXPECT_EQ(Voxel::isMatch(&expected_rots.at(i), &rotations.at(i)), true);
}
}
}
TEST(VoxelSpaces, AllPermutationsInPrism) {
auto space1 = Voxel::Space{
.space=30ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
auto prism_dims = std::array<int, 3>{ 3, 3, 3 };
auto perms = Voxel::getAllPermutationsInPrism(&space1, prism_dims.begin());
auto expected_perms = std::vector<uint64_t>{
30ul,
240ul,
15360ul,
122880ul,
7864320ul,
62914560ul,
153ul,
306ul,
78336ul,
156672ul,
40108032ul,
80216064ul,
266760ul,
533520ul,
1067040ul,
2134080ul,
4268160ul,
8536320ul,
263682ul,
527364ul,
2109456ul,
4218912ul,
16875648ul,
33751296ul,
2101761ul,
4203522ul,
8407044ul,
16814088ul,
33628176ul,
67256352ul,
525825ul,
1051650ul,
4206600ul,
8413200ul,
33652800ul,
67305600ul,
51ul,
408ul,
26112ul,
208896ul,
13369344ul,
106954752ul,
90ul,
180ul,
46080ul,
92160ul,
23592960ul,
47185920ul,
4680ul,
9360ul,
18720ul,
2396160ul,
4792320ul,
9584640ul,
1542ul,
12336ul,
98688ul,
789504ul,
6316032ul,
50528256ul,
36873ul,
73746ul,
147492ul,
18878976ul,
37757952ul,
75515904ul,
3075ul,
24600ul,
196800ul,
1574400ul,
12595200ul,
100761600ul,
};
ASSERT_EQ(expected_perms.size(), perms.size());
for (int i = 0; i < perms.size(); i++) {
if (i <= expected_perms.size()) {
EXPECT_EQ(expected_perms.at(i), perms.at(i));
}
}
}
TEST(VoxelSpaces, RotateXYZ) {
auto space1 = Voxel::Space{ .space=30ull, .dims={3, 3, 3}};
auto space2 = Voxel::Space{ .space=30ull, .dims={3, 3, 3}};
auto space3 = Voxel::Space{ .space=30ull, .dims={3, 3, 3}};
auto space1 = Voxel::Space{
.space=30ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
auto space2 = Voxel::Space{
.space=30ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
auto space3 = Voxel::Space{
.space=30ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
Voxel::rotate90X(&space1);
Voxel::rotate90Y(&space2);
Voxel::rotate90Z(&space3);
EXPECT_EQ(space1.space, 153ull);
EXPECT_EQ(space2.space, 1067040ull);
EXPECT_EQ(space3.space, 1574400ull);
EXPECT_EQ(space1.space, 153ul);
EXPECT_EQ(space2.space, 1067040ul);
EXPECT_EQ(space3.space, 1574400ul);
}
TEST(VoxelSpaces, GetAllPositionsInPrism) {
int dims[] = {3, 3, 3};
auto space1 = Voxel::Space{
.space=30ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
Voxel::cullEmptySpace(&space1);
uint64_t expected_results1[] = {
30ul,
240ul,
15360ul,
122880ul,
7864320ul,
62914560ul,
};
auto space2 = Voxel::Space{
.space=23ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
Voxel::cullEmptySpace(&space2);
uint64_t expected_results2[] = {
23ul,
184ul,
11776ul,
94208ul,
6029312ul,
48234496ul,
};
auto space3 = Voxel::Space{
.space=15ul,
.dim_x=3,
.dim_y=3,
.dim_z=3,
};
Voxel::cullEmptySpace(&space3);
uint64_t expected_results3[] = {
15ul,
120ul,
7680ul,
61440ul,
3932160ul,
31457280ul,
};
auto positions1 = Voxel::getAllPositionsInPrism(&space1, dims);
auto positions2 = Voxel::getAllPositionsInPrism(&space2, dims);
auto positions3 = Voxel::getAllPositionsInPrism(&space3, dims);
auto mismatches1 = std::vector<std::tuple<int, uint64_t, uint64_t>>();
auto mismatches2 = std::vector<std::tuple<int, uint64_t, uint64_t>>();
auto mismatches3 = std::vector<std::tuple<int, uint64_t, uint64_t>>();
for (int i = 0; i < 6; i++) {
if (positions1[i] != expected_results1[i]) {
mismatches1.push_back({ i, positions1[i], expected_results1[i] });
}
if (positions2[i] != expected_results2[i]) {
mismatches2.push_back({ i, positions2[i], expected_results2[i] });
}
if (positions3[i] != expected_results3[i]) {
mismatches3.push_back({ i, positions3[i], expected_results3[i] });
}
}
EXPECT_EQ(mismatches1.size(), 0);
if (mismatches1.size() > 0) {
std::cout << "Index - Actual - Expected" << std::endl;
for (auto &mismatch : mismatches1) {
std::cout << std::get<0>(mismatch) << " - " << std::get<1>(mismatch) << " - " << std::get<2>(mismatch) << std::endl;
}
}
EXPECT_EQ(mismatches2.size(), 0);
if (mismatches2.size() > 0) {
std::cout << "Index - Actual - Expected" << std::endl;
for (auto &mismatch : mismatches2) {
std::cout << std::get<0>(mismatch) << " - " << std::get<1>(mismatch) << " - " << std::get<2>(mismatch) << std::endl;
}
}
EXPECT_EQ(mismatches3.size(), 0);
if (mismatches3.size() > 0) {
std::cout << "Index - Actual - Expected" << std::endl;
for (auto &mismatch : mismatches3) {
std::cout << "At " << std::get<0>(mismatch) << ": " << std::get<1>(mismatch) << " != " << std::get<2>(mismatch) << std::endl;
}
}
}