def main():
parser = argparse.ArgumentParser(description=DESCRIPTION, epilog=EPILOG)
parser.add_argument("filename", nargs='?', help=FILENAME)
parser.add_argument("-a", help=FREQ_A, default=2, type=posint)
parser.add_argument("-b", help=FREQ_B, default=0,
type=nonnegativeint)
parser.add_argument("-m", '--mapping', default='flat', help=PROJ,
choices=projection.PROJECTIONS)
parser.add_argument("-n", "--no_normalize", action="store_true",
help="Don't normalize vertices onto the unit sphere")
parser.add_argument("-k", default=1, help=ADJ, type=kparser)
parser.add_argument("-t", "--tweak", action="store_true", help=TWEAK)
parser.add_argument("-f", "--factor", action="store_true", help=FACTOR)
args = parser.parse_args()
frequency = (args.a, args.b)
file = open(args.filename) if args.filename else stdin
if frequency == (1, 0):#identity, just give input back as output
with file as f:
print(f.read())
else:
with file as f:
vertices, faces, fc, _e, _ec, _v, _vc = off.load_off(f)
base = tiling.Tiling(vertices, faces)
classIlist = ['edges', 'aspect', 'angle', 'angle_aspect']
is_tri_grid = all(base.face_size <= 3)
if args.b == 0 and args.k in classIlist and is_tri_grid:
warnings.warn(args.k + " is optimal for a large range of k for "
"class I subdivision on triangle grid. "
"using -k=energy instead.")
k = 'energy'
elif args.k == 'bent' and is_tri_grid:
warnings.warn("bentness always == 0 for triangular faces. "
"Using -k=energy instead.")
k = 'energy'
else:
k = args.k
if args.factor:
poly = gcopoly.build_gco_rep(base, frequency, args.projection,
tweak=args.tweak, k=k,
normalize=not args.no_normalize)
else:
poly = gcopoly.build_gco(base, frequency, args.projection,
tweak=args.tweak, k=k,
normalize=not args.no_normalize)
vertcolor = poly.group.astype(int)
facecolor = poly.face_group.astype(int)
result = off.write_off(poly.vertices, poly.faces,
facecolors=facecolor,
vertexcolors=vertcolor)
result += '#frequency = {}\n'.format(frequency)
if args.filename:
result += '#input file = {}\n'.format(args.filename)
result += '#projection = {}\n'.format(args.projection)
if args.projection in projection.PARALLEL:
result += '#k = {}\n'.format(poly.k)
if args.projection in projection.PARALLEL + ['gc']:
result += '#tweak = {}\n'.format(args.tweak)
result += '#normalized = {}\n'.format(not args.no_normalize)
print(result)
def main():
parser = argparse.ArgumentParser(description="Create OFF files for each "
"method and a range of frequencies")
parser.add_argument("filename", help="filename")
parser.add_argument("-a", default=9, help="max frequency", type=int)
args = parser.parse_args()
file = open(args.filename)
with file as f:
vertices, faces, _fc, _e, _ec, _v, _vc = off.load_off(f)
base = tiling.Tiling(vertices, faces)
methods = METHODS_3
for a in range(1, args.a + 1):
for b in range(a + 1):
for proj, tweak in methods:
all_SGS(
args.filename.split('/')[-1], base, (a, b), proj, tweak)
def main():
desc = "Statistics of a tiling that are relevant to use as a grid"
parser = argparse.ArgumentParser(description=desc)
parser.add_argument("filename", nargs='*',
help="Input files. Reads from stdin if not given.")
parser.add_argument("-s", action="store_true",
help="Suppress spherical measures")
parser.add_argument("-c", help="Write to csv file")
args = parser.parse_args()
header = ['filename', 'n_v', 'n_f', 'energy', 'cog', 'bent_min',
'bent_max', 'edge_min', 'edge_max', 'aspect_ratio_min',
'aspect_ratio_max', 'faces_min', 'faces_max']
if not args.s:
header += ['angle_min', 'angle_max', 'angle_aspect_min',
'angle_aspect_max', 'solid_angle_min', 'solid_angle_max']
lines = [header]
if len(args.filename) == 1 and '*' in args.filename[0]:
handles = ((fn, open(fn)) for fn in glob.iglob(args.filename[0]))
elif args.filename:
handles = ((fn, open(fn)) for fn in args.filename)
else:
handles = [('stdin', stdin)]
for fn, h in handles:
with h as handle:
vertices, faces, fc, e, ec, v, vc = off.load_off(handle)
poly = tiling.Tiling(vertices, faces)
n_v = len(vertices)
n_f = len(faces)
energy = tiling.energy(vertices)
norm_cog = tiling.center_of_gravity(vertices)
bentness = tiling.bentness(vertices, poly)
bent_min, bent_max = bentness.min(), bentness.max()
edges = tiling.edge_length(vertices, poly.edges)
edge_min, edge_max = edges.min(), edges.max()
aspect = tiling.aspect_ratio(vertices, poly)
aspect_min, aspect_max = aspect.min(), aspect.max()
faces = tiling.face_area(vertices, poly)
face_min, face_max = faces.min(), faces.max()
values = [fn, n_v, n_f, energy, norm_cog,
bent_min, bent_max,
edge_min, edge_max,
aspect_min, aspect_max,
face_min, face_max]
print('---')
print('File: ', fn)
print('Vertices, faces: {}, {}'.format(n_v, n_f))
print('Thomson energy: ', energy)
if not np.isclose(0, norm_cog):
print('Distance of center of gravity from center:\t', norm_cog)
print('\t\t\t minimum |maximum |ratio')
print('Edge length:\t\t {:<,F}|{:<,F}|{:<,F}'.format(
edge_min, edge_max, edge_max/edge_min))
print('Aspect ratio:\t\t {:<,F}|{:<,F}|{:<,F}'.format(
aspect_min, aspect_max, aspect_max/aspect_min))
if np.isclose(0, bent_max, atol=1E-6):
print('Face area:\t\t {:<,F}|{:<,F}|{:<,F}'.format(
face_min, face_max, face_max/face_min))
else:
print('Face bentness: \t\t {:<,F}|{:<,F}|{:<,F}'.format(
bent_min, bent_max, bent_max/bent_min))
if not args.s:
edges = tiling.edge_length(vertices, poly.edges, spherical=True)
edge_min, edge_max = edges.min(), edges.max()
aspect = tiling.aspect_ratio(vertices, poly, spherical=True)
aspect_min, aspect_max = aspect.min(), aspect.max()
faces = tiling.face_area(vertices, poly, spherical=True)
face_min, face_max = faces.min(), faces.max()
values += [edge_min, edge_max, aspect_min, aspect_max,
face_min, face_max]
print('Central angle:\t\t {:<,F}|{:<,F}|{:<,F}'.format(
edge_min, edge_max, edge_max/edge_min))
print('Central angle aspect ratio: {:<,F}|{:<,F}|{:<,F}'.format(
aspect_min, aspect_max, aspect_max/aspect_min))
print('Solid angle:\t\t {:<,F}|{:<,F}|{:<,F}'.format(
face_min, face_max, face_max/face_min))
lines.append(values)
if args.c:
with open(args.c, 'w', newline='') as f:
writer = csv.writer(f)
writer.writerows(lines)
def main():
parser = argparse.ArgumentParser(description=DESCRIPTION)
parser.add_argument("filename",
nargs='?',
help="Input file. Reads from stdin if not given.")
parser.add_argument("-n", help="Number of steps", default=100, type=int)
parser.add_argument("-b",
help="Birth rule, comma-separated",
default=[1, 5, 6],
type=ruleparse)
parser.add_argument("-s",
help="Survival rule, comma-separated",
default=[1, 2],
type=ruleparse)
parser.add_argument("-l", help="Lookback", type=int, default=12)
parser.add_argument("-v", help=NEIGHBOR, action='store_true')
parser.add_argument("-d",
action='store_true',
help="Color the vertices "
"as if the cellular automata were operating on "
"the dual polyhedron/tiling")
parser.add_argument("-o", help="Output prefix.", default="cellular")
args = parser.parse_args()
file = open(args.filename) if args.filename else stdin
with file as f:
vertices, faces, fc, e, ec, verts, vc = off.load_off(f)
init = vc if args.d else fc
if init is None or np.ptp(init) == 0:
init = np.random.randint(2, size=len(faces))
init = np.asarray(init)
if len(init.shape) > 1:
raise ValueError("Need color indexes, not color values")
elif np.any(init > 1):
init = init > (init.max() + init.min()) / 2
poly = tiling.Tiling(vertices, faces)
if args.d:
adj = poly.vertex_f_adjacency if args.v else poly.vertex_adjacency
else:
adj = poly.face_v_adjacency if args.v else poly.face_adjacency
rule = np.array(args.b + [i - 128 for i in args.s], dtype=np.int8)
state = np.zeros((args.n + 1, len(init)), dtype=bool)
state[0] = init
lookback = args.l
width = int(np.ceil(np.log10(args.n + 2)))
file_template = args.o + "{:0" + str(width) + "d}" + ".off"
for i in range(args.n):
this_state = ca_step(state[i], rule, adj)
state[i + 1] = this_state
result = this_state.astype(int)
if args.d:
string = off.write_off(vertices,
faces,
facecolors=fc,
edges=e,
edgecolors=ec,
vertexcolors=result)
else:
string = off.write_off(vertices,
faces,
facecolors=result,
edges=e,
edgecolors=ec,
vertexcolors=vc)
fn = file_template.format(i + 1)
with open(fn, 'w') as f:
f.write(string)
start = max(i - lookback, 0)
if np.any(np.all(this_state == state[start:i + 1], axis=-1)):
string = "reached steady state at {}, breaking out early"
warnings.warn(string.format(i + 1))
break