def __init__(self, path):
ds = np.load(path)
self.train = ds["train"]
self.test = ds["test"]
self.val = ds["val"]
print("dataset loaded:", path)
self.og = ObjGenerator(MAX_GRID, 1.0)
self.paths = []
self.sample_idx = [
0, 0, 0, 0
] # corresponding to train labeled, train unlabeled, test, val
get_data_dir(),
"list-v2-snek_{}-grid_{}-final.pkl".format(SNEK_LEN_2, GRID_SIZE_2))
SNEK_LEN_3 = 14
GRID_SIZE_3 = 6
OUT_PATH_3 = os.path.join(
get_data_dir(),
"list-v2-snek_{}-grid_{}-final.pkl".format(SNEK_LEN_3, GRID_SIZE_3))
SNEK_LEN_4 = 15
GRID_SIZE_4 = 8
OUT_PATH_4 = os.path.join(
get_data_dir(),
"list-v2-snek_{}-grid_{}-final.pkl".format(SNEK_LEN_4, GRID_SIZE_4))
og1 = ObjGenerator(GRID_SIZE_1, 1.0)
og2 = ObjGenerator(GRID_SIZE_2, 1.0)
og3 = ObjGenerator(GRID_SIZE_3, 1.0)
og4 = ObjGenerator(GRID_SIZE_4, 1.0)
with open(OUT_PATH_1, "rb") as output_file:
final1 = pickle.load(output_file)
with open(OUT_PATH_2, "rb") as output_file:
final2 = pickle.load(output_file)
with open(OUT_PATH_3, "rb") as output_file:
final3 = pickle.load(output_file)
with open(OUT_PATH_4, "rb") as output_file:
final4 = pickle.load(output_file)
OUT_PATH = os.path.join(get_data_dir(), "object-{:06d}.obj")
# the size of the snake is randomly sampled
# from this interval
SNEK_LEN_MIN = 5
SNEK_LEN_MAX = 10
GRID_SIZE = 4 # the grid for the snake is N x N x N
CUBE_SIZE = 1.0 # cubes are unit-sized
### IMPORTANT
OBJECTS_TO_GENERATE = 1000
if __name__ == '__main__':
og = ObjGenerator(GRID_SIZE, CUBE_SIZE)
## test with one cube
# v, f = make_cube(CUBE_SIZE)
# plot_cube(v, f)
# test with one grid
g = og.walk_snek(SNEK_LEN_MIN, SNEK_LEN_MAX)
print(g)
v, f = og.grid_to_cubes(g)
og.write_obj(g, v, f, 0, OUT_PATH)
og.plot_cube(v, f)
# v, f = og.grid_to_cubes(np.flip(g,axis=0))
# og.plot_cube(v, f)
#
# from: https://open.spotify.com/user/spotify/playlist/37i9dQZEVXcHz1uKVd65vg?si=FIkd0LBAS9en1sRXxkH57A
IN_PATH = os.path.expanduser("~/data/ig/aggregated-question.pkl")
PARAMS = [(11, 5), (13, 5), (14, 6), (15, 8)]
MAX_GRID = 8
with open(IN_PATH, "rb") as output_file:
refs = pickle.load(output_file)
cola = pickle.load(output_file)
colb = pickle.load(output_file)
colc = pickle.load(output_file)
cold = pickle.load(output_file)
answ = pickle.load(output_file)
og = ObjGenerator(MAX_GRID, 1.0)
def plot_obj_from_list(in_list):
obj, idx = in_list
grid = np.array(obj).reshape(
(PARAMS[idx][1], PARAMS[idx][1], PARAMS[idx][1]))
uniform_grid = embed_in_bigger(grid, MAX_GRID)
v, f = og.grid_to_cubes(uniform_grid)
og.plot_cube(v, f)
# plt.show()
def embed_in_bigger(grid, bigger_size):
if grid.shape[0] == bigger_size:
return grid
import pickle
import os
import matplotlib.pyplot as plt
from inversegraphics_generator.obj_generator import ObjGenerator
from inversegraphics_generator.iqtest_objs import get_data_dir
SNEK_LEN = 9
GRID_SIZE = 4
OUT_PATH = os.path.join(
get_data_dir(), "tree-v2-snek_{}-grid_{}.pkl".format(SNEK_LEN, GRID_SIZE))
print("loading file:", OUT_PATH)
og = ObjGenerator(GRID_SIZE, 1.0)
def getLeafs(node):
if len(node.children) == 0:
return node
else:
out = [getLeafs(child) for child in node.children]
out_flat = []
for child in out: # each layer removes some mess
if type([]) == type(child):
for child2 in child:
out_flat.append(child2)
else:
out_flat.append(child)
return out_flat
root = pickle.load(open(OUT_PATH, "rb"))
import pickle
import os
from tqdm import tqdm
from inversegraphics_generator.obj_generator import ObjGenerator
from inversegraphics_generator.iqtest_objs import get_data_dir
import numpy as np
SNEK_LEN = 9
GRID_SIZE = 4
OUT_PATH = os.path.join(get_data_dir(),
"list-v2-snek_{}-grid_{}".format(SNEK_LEN, GRID_SIZE))
og = ObjGenerator(GRID_SIZE, 1.0)
final = []
with open(OUT_PATH + "-unique.pkl", "rb") as output_file:
unique = pickle.load(output_file)
for u in tqdm(unique):
# print (u)
u_grid = og.str_to_grid(u)
clean = True
for i in range(3):
tmp = og.grid_to_str(
og.center_grid(np.rot90(u_grid, k=i + 1, axes=(0, 1))))
if tmp in final:
OUT_PATH = os.path.join(
get_data_dir(), "tree-v2-snek_{}-grid_{}.pkl".format(SNEK_LEN, GRID_SIZE))
BREAK_A = -1
BREAK_B = 6
upper_bound = np.zeros(1, dtype=np.uint64)
upper_bound[0] = 16
# tmp_factorial = GRID_SIZE ** 3
# for _ in range(SNEK_LEN):
# upper_bound[0] *= tmp_factorial
# tmp_factorial -= 1
for _ in range(SNEK_LEN):
upper_bound[0] *= 5
print("upper bound:", upper_bound[0])
og = ObjGenerator(GRID_SIZE, 1.0)
root = AnyNode(id="root")
node_count = 0
# # initial layer - manual init
# node_data = np.zeros((GRID_SIZE, GRID_SIZE, GRID_SIZE), dtype=np.uint8)
# node_data[0, int(math.ceil(GRID_SIZE/2)), 0] = 2
# AnyNode(parent=root, id=node_data.tostring(), remaining=SNEK_LEN-1)
# node_count += 1
#
# node_data = np.zeros((GRID_SIZE, GRID_SIZE, GRID_SIZE), dtype=np.uint8)
# node_data[int(math.ceil(GRID_SIZE/2)), int(math.ceil(GRID_SIZE/2)), int(math.ceil(GRID_SIZE/2))] = 2
# AnyNode(parent=root, id=node_data.tostring(), remaining=SNEK_LEN-1)
# node_count += 1
import pickle
import os
from tqdm import tqdm
from inversegraphics_generator.obj_generator import ObjGenerator
from inversegraphics_generator.iqtest_objs import get_data_dir
SNEK_LEN = 9
GRID_SIZE = 4
IN_PATH = os.path.join(
get_data_dir(), "tree-v2-snek_{}-grid_{}.pkl".format(SNEK_LEN, GRID_SIZE))
print("loading file:", IN_PATH)
OUT_PATH = os.path.join(get_data_dir(),
"list-v2-snek_{}-grid_{}".format(SNEK_LEN, GRID_SIZE))
og = ObjGenerator(GRID_SIZE, 1.0)
def getLeafs(node):
if len(node.children) == 0:
return node
else:
out = [getLeafs(child) for child in node.children]
out_flat = []
for child in out: # each layer removes some mess
if type([]) == type(child):
for child2 in child:
out_flat.append(child2)
else:
out_flat.append(child)
return out_flat
# tmp_factorial = GRID_SIZE ** 3
# for _ in range(SNEK_LEN):
# upper_bound[0] *= tmp_factorial
# tmp_factorial -= 1
for _ in range(SNEK_LEN - 1):
upper_bound[0] *= 6
print("upper bound:", upper_bound[0])
# a = np.eye(5,dtype=np.uint8)
# print (a)
# b = a.tostring()
# print (b)
# c = np.fromstring(b, dtype=np.uint8).reshape((5,5))
# print (c)
og = ObjGenerator(GRID_SIZE, 1.0)
root = AnyNode(id="root")
node_count = 0
# initial layer
for x in range(GRID_SIZE):
for y in range(GRID_SIZE):
for z in range(GRID_SIZE):
node_data = np.zeros((GRID_SIZE, GRID_SIZE, GRID_SIZE),
dtype=np.uint8)
node_data[x, y, z] = 2
node = AnyNode(parent=root, id=node_data.tostring())
node_count += 1
class IqObjDataset(object):
def __init__(self, path):
ds = np.load(path)
self.train = ds["train"]
self.test = ds["test"]
self.val = ds["val"]
print("dataset loaded:", path)
self.og = ObjGenerator(MAX_GRID, 1.0)
self.paths = []
self.sample_idx = [
0, 0, 0, 0
] # corresponding to train labeled, train unlabeled, test, val
def _grid_to_file(self, grid, folder, idx, filepattern="{:06d}.obj"):
v, f = self.og.grid_to_cubes(grid)
out_path = os.path.join(folder.name, filepattern.format(idx))
self.og.write_obj(grid, v, f, out_path)
def sample_unordered(self, dataset, sidx, n=1):
# make tmp dir
folder = tempfile.TemporaryDirectory()
self.paths.append(folder)
# get N samples and write to disk
for idx in range(n):
self.sample_idx[sidx] += 1
if self.sample_idx[sidx] == len(dataset):
self.sample_idx[sidx] = 0
self._grid_to_file(dataset[self.sample_idx[sidx], 0], folder,
self.sample_idx[sidx])
# return path
return folder.name
def sample_qa(self, dataset, sidx, n=1):
# make tmp dir
folder = tempfile.TemporaryDirectory()
self.paths.append(folder)
# get N samples and write to disk
for idx in range(n):
self.sample_idx[sidx] += 1
if self.sample_idx[sidx] == len(dataset):
self.sample_idx[sidx] = 0
self._grid_to_file(dataset[self.sample_idx[sidx], 0], folder,
self.sample_idx[sidx], "{:06d}-ref.obj")
self._grid_to_file(dataset[self.sample_idx[sidx], 1], folder,
self.sample_idx[sidx], "{:06d}-ans1.obj")
self._grid_to_file(dataset[self.sample_idx[sidx], 2], folder,
self.sample_idx[sidx], "{:06d}-ans2.obj")
self._grid_to_file(dataset[self.sample_idx[sidx], 3], folder,
self.sample_idx[sidx], "{:06d}-ans3.obj")
# return path
return folder.name
def get_training_samples_unordered(self, n=1):
return self.sample_unordered(self.train, 1, n)
def get_training_questions_answers(self, n=1):
return self.sample_qa(self.train, 0, n)
def get_testing_questions_answers(self, n=1):
return self.sample_qa(self.test, 2, n)
def get_validation_questions_answers(self, n=1):
return self.sample_qa(self.val, 3, n)
def cleanup(self):
for tmp in self.paths:
tmp.cleanup()