def cmd_assemble():
"""gets the arguments from the command line parameters"""
parser = argparse.ArgumentParser(description='Assemble ARM assembly code')
parser.add_argument('infile', metavar='INFILE', help='file containing code to assemble')
parser.add_argument('outfile', metavar='OUTFILE', help='file to write the binary output to')
args = parser.parse_args()
assembler.assembler(args.infile, args.outfile)
def testeAssembly(jarAssembler, jarVM, testDir, vmDir, nasmDir, hackDir, gui,
verbose):
# Compila java
genJAR()
# Gera nasm from VM
print("------------------------------")
print("- Translating files ")
print("- to I-VMTranslator/bin/nasm/ ")
print("------------------------------")
vmtranslator(vmDir, nasmDir)
# montador
print("-------------------------")
print("- Assembling files .... ")
print("-------------------------")
assembler(jarAssembler, nasm, hack, True)
# simulando
print("-------------------------")
print("- Simulating .... ")
print("-------------------------")
simulateFromTestDir(testDir, hackDir, gui, verbose)
# testAssembling files
print("-------------------------")
print("- Testando .... ")
print("-------------------------")
compareFromTestDir(testDir)
def testeVM(jarAssembler, jarVM, testDir, vmDir, nasmDir, hackDir, gui,
verbose):
# gera jar
if (genJAR()):
print("Erro no java")
exit(1)
# translate vM
translateVm(False, jarVM)
# montador
print("-------------------------")
print("- Assembling files .... ")
print("-------------------------")
assembler(jarAssembler, nasm, hack, True)
# simulando
print("-------------------------")
print("- Simulating .... ")
print("-------------------------")
simulateFromTestDir(testDir, hackDir, gui, verbose)
# testAssembling files
print("-------------------------")
print("- Testando .... ")
print("-------------------------")
compareFromTestDir(testDir)
def testeAssembly(jar, testDir, nasmDir, hackDir, gui, verbose):
pwd = os.path.dirname(os.path.abspath(__file__))
# global path
os.path.abspath(nasm)
os.path.abspath(hack)
# compila
print("-------------------------")
print("- Assembling files .... ")
print("-------------------------")
assembler(jar, nasm, hack, True)
# simulando
print("-------------------------")
print("- Simulating .... ")
print("-------------------------")
simulateFromTestDir(testDir, hackDir, gui, verbose)
# testAssembling files
print("-------------------------")
print("- Testando .... ")
print("-------------------------")
compareFromTestDir(testDir)
def compileNASM(jar, nasmDir, hackDir):
# compila
print("-------------------------")
print("- Assembling files .... ")
print("-------------------------")
assembler(jar, nasm, hack, True)
def testeVM(jarAssembler, jarVM, gui, verbose):
pwd = os.path.dirname(os.path.abspath(__file__))
testDir = pwd + "/../I-VM/tests/"
vmDir = pwd + "/../I-VM/src/vm/"
vmExeDir = pwd + "/../I-VM/src/vmExamples/"
nasm = pwd + "/bin/nasm/"
hack = pwd + "/bin/hack/"
# VM -> nasm
compileVM(False, vmDir, nasm, jarVM)
compileVM(False, vmExeDir, nasm, jarVM)
# nasm -> hack
print("-------------------------")
print("- Assembling files .... ")
print("-------------------------")
assembler(jarAssembler, nasm, hack, True)
# hack ->
print("-------------------------")
print("- Simulating .... ")
print("-------------------------")
simulateFromTestDir(testDir, hack, gui, verbose)
# testAssembling files
print("-------------------------")
print("- Testando .... ")
print("-------------------------")
compareFromTestDir(testDir)
def compile(nasm, hack, mif):
pwd = os.path.dirname(os.path.abspath(__file__))
# global path
os.path.abspath(nasm)
os.path.abspath(hack)
assembler(jar, nasm, hack, True)
def program(nasm):
jar = os.path.join(TOOLS_SCRIPT_PATH, '..', 'jar', 'Z01-Assembler.jar')
pwd = os.path.dirname(os.path.abspath(__file__))
hack = pwd+"/bin/hack/"+os.path.splitext(os.path.basename(nasm))[0]
# global path
nasm = os.path.abspath(nasm)
hack = os.path.abspath(hack)
# assembler
assembler(jar, nasm, hack, True)
def testeAssembly(jar, nasmDir, hackDir):
# global path
os.path.abspath(nasm)
os.path.abspath(hack)
# compila
print("-------------------------")
print("- Assembling files .... ")
print("-------------------------")
assembler(jar, nasm, hack, True)
def program(nasm):
pwd = os.path.dirname(os.path.abspath(__file__))
hack = pwd + "/../bin/hack/" + os.path.splitext(os.path.basename(nasm))[0]
# global path
nasm = os.path.abspath(nasm)
hack = os.path.abspath(hack)
# assembler
assembler(jar, nasm, hack, True)
# program ROM
writeROM(hack + ".mif")
def testeAssembly(jar, testDir, nasmDir, hackDir, gui, verbose):
pwd = os.path.dirname(os.path.abspath(__file__))
# global path
os.path.abspath(nasm)
os.path.abspath(hack)
print("==== Assembling Files ==========================")
clearbin(hack)
errAssembler, logAssembler = assembler(jar, nasm, hack, True)
if errAssembler == 0:
print("==== Simulating ================================")
clearTestDir(testDir)
if simulateFromTestDir(testDir, hackDir, gui, verbose) < 0:
sys.exit(1)
# testAssembling files
print("==== Testando ==================================")
error, log = compareFromTestDir(testDir)
if error < -1:
sys.exit(-1)
# report error
print("==== Reporting results =========================")
r = report(log, 'H')
error = r.assemblyTeste(log)
r.send()
def assemble_block_with_model(model, raw_vol, overlap, blend_fac):
def predict(raw_block):
# temp=np.zeros((np.shape(raw_block)[aff_graph0]*2,np.shape(raw_block)[2]*2,np.shape(raw_block)[2]*2))
# temp[int(np.shape(raw_block)[aff_graph0]/2):int(np.shape(raw_block)[aff_graph0]/2)+np.shape(raw_block)[aff_graph0],int(np.shape(raw_block)[1]/2):int(np.shape(raw_block)[1]/2)+np.shape(raw_block)[1],int(np.shape(raw_block)[2]/2):int(np.shape(raw_block)[2]/2)+np.shape(raw_block)[2]]=raw_block
# temp=np.reshape(temp,(1,np.shape(temp)[aff_graph0],np.shape(temp)[1],np.shape(temp)[2],1))
raw_block = np.reshape(raw_block, (1, 16, 128, 128, 1))
aff = model.predict(raw_block)
aff = np.einsum("bzxyc->bczxy", aff)
aff = aff[0]
return aff
shape = model.input_shape[1:-1]
builder = assembler.assembler(raw_vol, overlap, shape, predict, blend_fac)
print("\nBuilding affinity block...\n")
aff = builder.process()
print("\nBlock building done.\n")
return aff
def createFont(fontFormat, outputPath, manifest, glyphs, ttx_output,
dev_ttx_output):
"""
Calls the functions that assemble and create a font.
"""
log.out(f'[{fontFormat}]', 36)
# VARIABLES
extension = formats[fontFormat]["extension"]
imageFormat = formats[fontFormat]["imageFormat"]
outputAbsolute = pathlib.Path(outputPath).absolute()
# assemble TTX
log.out(f'Assembling initial TTX...')
originalTTX = assembler(fontFormat, manifest, glyphs)
log.out(f'Initial TTX successfully assembled.', 32)
# save TTX
log.out(f'Saving initial TTX to file...')
originalTTXPath = outputAbsolute / (f"{fontFormat}_initial.ttx")
writeFile(originalTTXPath, originalTTX,
'Could not write initial TTX to file')
log.out(f'Initial TTX saved.', 32)
# compile TTX to font
log.out(f'Compiling font...')
outputFontPath = outputAbsolute / (fontFormat + extension)
compileTTX(originalTTXPath, outputFontPath)
log.out(f'Font compiled.', 32)
# --dev-ttx flag
if not dev_ttx_output:
log.out(f'Deleting initial TTX...')
originalTTXPath.unlink() #delete
# -ttx flag
if ttx_output:
log.out(f'Compiling finished TTX..')
afterExportTTX = outputAbsolute / (f"{fontFormat}_finished.ttx")
compileTTX(outputFontPath, afterExportTTX)
# iOS Configuration Profile compilation
# (must come after everything else)
if formats[fontFormat]["iOSCompile"]:
log.out(f'Compiling iOS Configuration Profile...')
configString = compileiOSConfig(manifest, outputFontPath, outputPath)
configPath = outputAbsolute / (f"{fontFormat}.mobileconfig")
writeFile(configPath, configString,
'Could not write iOS Configuration Profile to file')
log.out(f'Deleting the original Font...')
outputFontPath.unlink() #delete
log.out(f'Done!!!', 32)
def testeAssembly(jarAssembler, jarVM, testDir, vmDir, nasmDir, hackDir, gui,
verbose):
compileVM(False, jarVM)
# montador
print("-------------------------")
print("- Assembling files .... ")
print("-------------------------")
assembler(jarAssembler, nasm, hack, True)
# simulando
print("-------------------------")
print("- Simulating .... ")
print("-------------------------")
simulateFromTestDir(testDir, hackDir, gui, verbose)
# testAssembling files
print("-------------------------")
print("- Testando .... ")
print("-------------------------")
compareFromTestDir(testDir)
def testeAssembly(jar, testDir, nasmDir, hackDir, gui, verbose):
# Compila java
genJAR()
# compila
print("-------------------------")
print("- Assembling files .... " )
print("-------------------------")
assembler(jar, nasm, hack, True)
# simulando
print("-------------------------")
print("- Simulating .... ")
print("-------------------------")
simulateFromTestDir(testDir, hackDir, gui, verbose)
# testAssembling files
print("-------------------------")
print("- Testando .... ")
print("-------------------------")
compareFromTestDir(testDir)
def assemble_block_with_model_location(model_funct, model_file, raw_vol,
overlap, blend_fac):
time_b = time.time()
mem_b = psutil.virtual_memory().used
print("\nGrabing model...\n")
model = model_funct()
model.load_weights(model_file)
def predict(raw_block):
# temp=np.zeros((np.shape(raw_block)[aff_graph0]*2,np.shape(raw_block)[2]*2,np.shape(raw_block)[2]*2))
# temp[int(np.shape(raw_block)[aff_graph0]/2):int(np.shape(raw_block)[aff_graph0]/2)+np.shape(raw_block)[aff_graph0],int(np.shape(raw_block)[1]/2):int(np.shape(raw_block)[1]/2)+np.shape(raw_block)[1],int(np.shape(raw_block)[2]/2):int(np.shape(raw_block)[2]/2)+np.shape(raw_block)[2]]=raw_block
# temp=np.reshape(temp,(1,np.shape(temp)[aff_graph0],np.shape(temp)[1],np.shape(temp)[2],1))
raw_block = np.reshape(raw_block, (1, 16, 128, 128, 1))
aff = model.predict(raw_block)
aff = np.einsum("bzxyc->bczxy", aff)
aff = aff[0]
return aff
shape = model.input_shape[1:-1]
builder = assembler.assembler(raw_vol, overlap, shape, predict, blend_fac)
print("\nBuilding affinity block...\n")
aff = builder.process()
print("\nBlock building done.\n")
time_e = time.time()
mem_a = psutil.virtual_memory().used
log.log("assemble", np.shape(raw_vol), time_e - time_b, mem_a - mem_b)
return aff
def predict_affins_and_save(model_funct,
model_file,
raw_vol,
overlap,
save_loc,
shape=[16, 128, 128]):
model = model_funct()
model.load_weights(model_file)
def predict(raw_block):
# temp=np.zeros((np.shape(raw_block)[aff_graph0]*2,np.shape(raw_block)[2]*2,np.shape(raw_block)[2]*2))
# temp[int(np.shape(raw_block)[aff_graph0]/2):int(np.shape(raw_block)[aff_graph0]/2)+np.shape(raw_block)[aff_graph0],int(np.shape(raw_block)[1]/2):int(np.shape(raw_block)[1]/2)+np.shape(raw_block)[1],int(np.shape(raw_block)[2]/2):int( np.shape( raw_block)[2]/2)+np.shape(raw_block)[2]]=raw_block
# temp=np.reshape(temp,(1,np.shape(temp)[aff_graph0],np.shape(temp)[1],np.shape(temp)[2],1))
raw_block = np.reshape(raw_block, (1, 16, 128, 128, 1))
aff = model.predict(raw_block)
aff = np.einsum("bzxyc->bczxy", aff)
aff = aff[0]
return aff
tag = model_file.split("/")[-1]
builder = assembler.assembler(raw_vol, overlap, shape, predict, 1)
print("\nBuilding affinity block...\n")
aff = builder.process()
print("\nBlock building done.\n")
np.save(save_loc + "/predicted_affinities-" + tag, aff)
return aff
def sniff(self, args):
'''
Configures the packet sniffer based on the command line arguments args
Decides based on args whether the sniff live or from a file
Creates the base pDict object based on args
Parameters:
argObject args - The object containing the command line arguments as attributes mapped with their values
Returns: None
'''
self.assembler = assembler.assembler()
self.display = display.display(args.allPackets, args.jsonFormat)
# either read from a packet capture file
# or capture packets live from a network interface
# the network interface is given by args.interface
if args.iFile:
self.fileCap(args)
else:
self.liveCap(args)
exit
# print("reorder lol")
yield clock.timeout(1)
def writeBack(clock):
while True:
# print("writeBack lol")
yield clock.timeout(1)
def halfBytes(t):
return t >> 12, (t >> 8) & 15, (t >> 4) & 15, t & 15
if __name__ == '__main__':
program = assembler.assembler(argv[1])
memory = program.memory
arf = arf.registerFile(program.regValues)
one_tick = 1
addSubDelay = 1
mulDelay = 2
loadStoreDelay = 4
fetchLatch = 0
fetchedPC = -1
bufferSize = 16
dispatchBuffer = []
__author__ = 'mishelle123'
import Parser as P
import Code as C
import sys
import assembler as A
import os
if __name__ == '__main__':
a = A.assembler()
path = sys.argv[1]
#open files in a folder
if os.path.isdir(path):
files_in_dir = os.listdir(path)
for file_in_dir in files_in_dir:
if file_in_dir.endswith("asm"):
a.assemble(path+"/"+file_in_dir)
#open one file
elif path.endswith("asm"):
a.assemble(path)
return r
usedd = False
usebe = False
print('Press enter to load default configuration.')
print('Type characters for other configurations.')
print('d = use disk_data.dasm, b = use big endian.')
config = input('usr>')
if 'd' in config: usedd = True
if 'b' in config: usebe = True
if True:
try:
entropy = assembler('../src/Kernel/main.dasm', True)
if not entropy.success:
print('Entropy main file missing!')
print('\n====== BUILD FAILED ======\n')
nul = input('Press enter to continue...')
exit()
diskdata = assembler('../src/Kernel/disk_data.dasm', True)
if not diskdata.success:
print('disk_data.dasm missing, diskdata option unavailable')
usedd = False
disklist = entropy.readfile('disklist.txt')
filedata = []
if not disklist:
print('disklist.txt not found, no files were added.')
rs = ((len(entropy.words) - 1) >> 9) + 1
#reader.getfiles()
#TODO Custom address line for personalisation
print('\n')
greeting = input('Please type the greeting you would like (include commas)> ')
job = input('Please type the job name > ')
print(cfg.chosen)
#TODO Add extra paragraphs for choice logic
#TODO Organise components into file
header = open('cvheader.txt')
header = header.read()
jobheader = header.replace('<JOB>', job)
footer = open('cvfooter.txt')
#TODO Create newline after point 3 (one line, not two)
cfg.coverletter.add_paragraph(greeting)
cfg.coverletter.add_paragraph()
cfg.coverletter.add_paragraph(jobheader)
reader.displayfiles('points')
assembler.assembler()
#cfg.coverletter.add_paragraph()
cfg.coverletter.add_paragraph()
cfg.coverletter.add_paragraph(footer)
cfg.coverletter.add_paragraph()
cfg.coverletter.add_paragraph('Yours Sincerley,')
cfg.coverletter.add_paragraph(yourName)
#TODO Formatting
cfg.coverletter.save(yourName + 'Cover Letter 2018.docx')
import argparse
from assembler import get_config, assembler
from download_celeba import celeba_dataloader
from pytorch_lightning import Trainer
import torchvision.transforms as transforms
# Load configs
parser = argparse.ArgumentParser(description='Generic runner for VAE models')
parser.add_argument('--config', '-c',
dest="filename",
metavar='FILE',
help = 'path to the config file',
default='configs/vae.yaml')
args = parser.parse_args()
config = get_config(args.filename)
vae = assembler(config, "training")
# Load data
dm = celeba_dataloader(config["exp_params"]["batch_size"],
config["exp_params"]["img_size"],
config["exp_params"]["crop_size"],
config["exp_params"]["data_path"])
# Run Training Loop
trainer= Trainer(gpus = config["trainer_params"]["gpus"],
max_epochs = config["trainer_params"]["max_epochs"])
trainer.fit(vae, datamodule=dm)
torch.save(vae.state_dict(), f"{vae.model.name}_celeba_conv.ckpt")
def calc_assemble():
"""prompts the user for the arguments"""
inf = input('in:')
outf = input('out:')
return assembler.assembler(inf, outf)
__author__ = 'mishelle123'
import Parser as P
import Code as C
import sys
import assembler as A
import os
if __name__ == '__main__':
a = A.assembler()
path = sys.argv[1]
#open files in a folder
if os.path.isdir(path):
files_in_dir = os.listdir(path)
for file_in_dir in files_in_dir:
if file_in_dir.endswith("asm"):
a.assemble(path + "/" + file_in_dir)
#open one file
elif path.endswith("asm"):
a.assemble(path)
def calc_validation_loss(self):
time_s=time.time()
print("\nCalculating validation loss...")
if len(self.validation_loss_list)==0:
#self.model.compile(loss=self.__get_loss(), optimizer=self.optimizer, metrics=['accuracy'])
self.__compile_model(loss=self.__get_loss())
#blocks will go in zxyc
provider_aff_0=assembler.assembler(self.validation_aff[0],0,self.input_shape[1:-1],None,1)
provider_aff_1=assembler.assembler(self.validation_aff[1],0,self.input_shape[1:-1],None,1)
provider_aff_2=assembler.assembler(self.validation_aff[2],0,self.input_shape[1:-1],None,1)
provider_gt=assembler.assembler(self.validation_gt,0,self.input_shape[1:-1],None,1)
provider_raw=assembler.assembler(self.validation_raw,0,self.input_shape[1:-1],None,1)
aff_blocks_0=provider_aff_0.provide_all_raw_blocks()
aff_blocks_1=provider_aff_1.provide_all_raw_blocks()
aff_blocks_2=provider_aff_2.provide_all_raw_blocks()
gt_blocks=provider_gt.provide_all_raw_blocks()
raw_blocks=provider_raw.provide_all_raw_blocks()
self.validation_data = [raw_blocks, gt_blocks, aff_blocks_0, aff_blocks_1, aff_blocks_2]
#loss goes in bzxyc
else:
raw_blocks=self.validation_data[0]
gt_blocks=self.validation_data[1]
aff_blocks_0=self.validation_data[2]
aff_blocks_1=self.validation_data[3]
aff_blocks_2=self.validation_data[4]
loss_info=np.zeros((1,4,self.input_shape[1],self.input_shape[2],self.input_shape[3]))
raw=np.zeros((1,1,self.input_shape[1],self.input_shape[2],self.input_shape[3]))
loss=0
for i in range(0,np.shape(raw_blocks)[0]):
aff_block_0=aff_blocks_0[i]
aff_block_1=aff_blocks_1[i]
aff_block_2=aff_blocks_2[i]
gt_block=gt_blocks[i]
raw_block=raw_blocks[i]
loss_info[0,0]=aff_block_0
loss_info[0,1]=aff_block_1
loss_info[0,2]=aff_block_2
loss_info[0,3]=gt_block
raw[0,0]=raw_block
info = self.model.evaluate(np.einsum("bczxy->bzxyc", raw), np.einsum("bczxy->bzxyc", loss_info), verbose=0)
loss += info[0]
#print("A")
#info = self.model.evaluate(np.einsum("bczxy->bzxyc", raw), np.einsum("bczxy->bzxyc", loss_info), verbose=0)
loss += info[0]
print("\nTIME %f"%(time.time()-time_s))
print("\nValidation loss: "+str(loss))
return loss
raw = np.load("data/spir_raw.npy")
raw = raw[0:25, 0:250, 0:250]
raw = np.einsum("zxy->xyz", raw)
#blending on z axis is bad (2 axis)
#y axis is 2 axis is verticle on images
#x axis is aff_graph0 axis and horizontal on image
def function(input):
return np.asarray([input, input, input])
builder = assembler.assembler(raw, .5, (128, 128, 16), function)
aff = builder.process()
#code.interact(local=locals())
raw = np.einsum("xyz->zxy", raw)
aff = np.einsum("cxyz->czxy", aff)
assert np.equal(raw, aff[0]).all()
for i in range(0, np.shape(aff)[1]):
tif.imsave("assembler_testing/processed/proc%i" % i,
np.asarray(aff[0, i, :, :], dtype=np.float32))
tif.imsave("assembler_testing/act0/act0%i" % i,
np.asarray(raw[i, :, :], dtype=np.float32))
printNote()
# Create directory for output file storage
if os.path.exists(prefix):
print(':: Directory with prefix already exists ::')
sys.exit(1)
os.makedirs(prefix)
ft_parser.printRes(inputFile, preamble, fnames)
# Prevent accidental overwrite of old assembly file
if os.path.isfile(fnames[2]):
resp = input(' ' + fnames[2] + ' already exists! Overwrite it (y/n)? ')
if resp == 'y' or resp == 'yes':
print(':: Overwriting... ::')
print()
else:
print(':: Aborting. ::')
print()
sys.exit(0)
pass_one = preamble + 'pass1_' + fnames[2]
ft_generator.printRes(pass_one, fnames[2], preamble + fnames[1])
assembler.assembler ("assembly_code.txt", "output_assembly.txt", "error_assembly.txt")
print(':: Compiler finished successfully ::')
print(':: Check the directory .' + sep + prefix + ' for extra data ::')
print()
import argparse
from assembler import get_config, assembler
from download_celeba import celeba_dataloader
from pytorch_lightning import Trainer
import torchvision.transforms as transforms
# Load configs
parser = argparse.ArgumentParser(description='Generic runner for VAE models')
parser.add_argument('--config',
'-c',
dest="filename",
metavar='FILE',
help='path to the config file',
default='configs/vae.yaml')
args = parser.parse_args()
config = get_config(args.filename)
gan = assembler(config)
# Load data
dm = celeba_dataloader(config["exp_params"]["batch_size"],
config["exp_params"]["img_size"],
config["exp_params"]["crop_size"],
config["exp_params"]["data_path"])
# Run Training Loop
trainer = Trainer(gpus=config["trainer_params"]["gpus"],
max_epochs=config["trainer_params"]["max_epochs"])
trainer.fit(gan, datamodule=dm)
torch.save(gan.state_dict(), f"{gan.name}_celeba.ckpt")
Computes the displacement solution for an assembly
of 1D spring elements under point loads.
"""
import numpy as np
import starter as sta
import assembler as ass
from datetime import datetime
start_time = datetime.now()
"""
PRE-PROCESSING
"""
nodes, mats, elements, loads = sta.readin()
ne, nn, nm, nl = sta.proini(nodes, mats, elements, loads)
DME, IBC, neq = ass.DME(nn, ne, nodes, elements)
"""
ASSEMBLY
"""
KG = np.zeros([neq, neq])
for i in range(ne):
kloc, ndof = ass.retriever(elements, mats, nodes, i)
KG = ass.assembler(KG, neq, kloc, ndof, DME, i)
RHSG = ass.loadasem(loads, IBC, neq, nl)
"""
SYSTEM SOLUTION
"""
UG = np.linalg.solve(KG, RHSG)
if not (np.allclose(np.dot(KG, UG), RHSG)):
print("The system is not in equilibrium!")
end_time = datetime.now()
print('Duration for system solution: {}'.format(end_time - start_time))
#temp[int(np.shape(raw_block)[aff_graph0]/2):int(np.shape(raw_block)[aff_graph0]/2)+np.shape(raw_block)[aff_graph0],int(np.shape(raw_block)[1]/2):int(np.shape(raw_block)[1]/2)+np.shape(raw_block)[1],int(np.shape(raw_block)[2]/2):int(np.shape(raw_block)[2]/2)+np.shape(raw_block)[2]]=raw_block
#temp=np.reshape(temp,(1,np.shape(temp)[aff_graph0],np.shape(temp)[1],np.shape(temp)[2],1))
raw_block = np.reshape(raw_block, (1, 16, 128, 128, 1))
aff = model.predict(raw_block)
aff = np.einsum("bzxyc->bczxy", aff)
aff = aff[0]
return aff
raw = np.load("data/spir_raw.npy")
raw = raw[0:32, :, :]
overlap_out_of_16 = 12
blending_factor = 1
asmblr = assembler.assembler(raw, overlap_out_of_16 / 16, (16, 128, 128),
predict, blending_factor)
aff = asmblr.process()
np.save("data/spir_bin2_aff%i" % itteration, aff)
