def render():
if gamemode == MENU:
menu.render(screen)
elif gamemode == PLAYING:
screen.fill(SKY)
world.render(screen, viewport)
if DEBUG:
#render debug text
h = 10
fpsimg = font.render("fps: " + str(clock.get_fps()), 0, WHITE)
screen.blit(fpsimg, (10, h))
h += fpsimg.get_height()
posimg = font.render("pos: [{0:.2f}".format(player.pos[0]) + ", {0:.2f}]".format(player.pos[1]), 0, WHITE)
screen.blit(posimg, (10, h))
h += posimg.get_height()
chunk = world.loaded_chunks.get(Convert.world_to_chunk(player.pos[0])[1])
chunkimg = font.render("chunk: " + str(chunk.x), 0, WHITE)
screen.blit(chunkimg, (10, h))
h += chunkimg.get_height()
biomeimg = font.render("biome: " + str(chunk.biome["name"]), 0, WHITE)
screen.blit(biomeimg, (10, h))
h += biomeimg.get_height()
player.render(screen, Convert.world_to_viewport(player.pos, viewport))
if gui is None:
target_pos = world.find_pos(world.find_angle(player, pygame.mouse.get_pos(), viewport),
Convert.pixels_to_viewport(player.pixel_pos(True), viewport),
pygame.mouse.get_pos(),
player.get_break_distance())
screen.blit(img_target, [x - y for x, y in zip(target_pos, [dim / 2 for dim in img_target.get_size()])]) #zoo-wee mama!
else:
gui.render(screen)
pygame.display.flip()
def CBC_Mode_Decryption(file_name, key, init_vec, block_size=1):
res = ''
cur_vec = init_vec
with open(file_name, 'rb') as f:
data = f.read()
key_len = len(key)
key_idx = 0
for idx in range(len(data) / block_size):
temp = data[idx * block_size:(idx + 1) * block_size]
temp = Convert.to_bin(temp)
temp = int(temp, 2)
tmp = ''
for char in data[idx * block_size:(idx + 1) * block_size]:
char = ord(char) - key[key_idx % key_len]
if char < 0:
char += 256
tmp += chr(char)
tmp = int(Convert.to_bin(tmp), 2)
tmp ^= cur_vec
tmp = bin(tmp)[2:]
tmp = '0' * (block_size * 8 - len(tmp)) + tmp
tmp = Convert.to_str(tmp)
key_idx += 1
res += tmp
cur_vec = temp
with open(file_name[:file_name.index('_cipher.txt')] + '_plain.txt',
'w') as f:
f.write(res)
def deploy(config):
caffe.set_mode_gpu()
if config.gpu is not None:
caffe.set_device(int(config.gpu))
classifier = caffe.Classifier(config.modelPrototxt, config.trainedModel)
images = Convert.loadImages(config.deployImages)
if config.deployRange is not None:
images = images[config.deployRange, ...]
mirroredImages = Convert.mirrorEdges(config.subImageSize, images,
config.debug) * 0.00390625
probs = np.zeros((images.size, 2))
n, h, w = images.shape
b = config.deployBatch
imageSize = h * w
print("Start Deploying")
for ni in range(n):
print("\tDeploying Image %s" % config.deployRange[ni])
for hi in range(h):
for wi in range(0, w, b):
batches = []
for bi in range(wi, wi + b):
image = mirroredImages[ni, hi:hi + config.subImageSize,
bi:bi + config.subImageSize]
# data is K x H x W X C array, so add channel axis
batches.append(image[:, :, np.newaxis])
prob = classifier.predict(batches, oversample=False)
i = ni * imageSize + hi * h + wi
probs[i:i + b] = prob
probs = probs.reshape(n, h, w, 2)
np.save(config.likelihood, probs)
def main():
# input
h = 0.0 # km
v = 12.5 # m/s
c = Convert(1.0, 'ft', 'm')
naca = '2408'
b = Convert(12.0, 'ft', 'm')
lam = Convert(0.0, 'deg', 'rad')
# constants
gamma = 1.4
Rgas = 287.15
# atmosphere
P, T = atm.atmosphere(h)
rho = atm.density(P, T)
mu = atm.viscosity(T)
a = sqrt(gamma * Rgas * T)
M = v / a
# calculations
Re = (rho * v * c) / mu
S = b * c # fix to include lam later
AR = (b * b) / S
e = 0.95
zero_lift, astall, cl, cd = airfoil(naca, Re, M)
def update_telemetry(self, telemetry_data):
if (self.view_type == ViewTypes.ARDUINO):
#tlv = ArduinoHelper.create_tlv(telemetry_data)
tlv_lcd = ArduinoHelper.create_lcd_tlv(telemetry_data)
tlv_led = ArduinoHelper.create_led_tlv(telemetry_data)
#print("".join("%02x" % b for b in tlv.serialize()))
self.serial.write(tlv_lcd.serialize())
self.serial.write(tlv_led.serialize())
print("------------SPEED-------------")
print(" " + str(int(Convert.speed_to_kph(telemetry_data.speed))) + " KPH")
elif (self.view_type == ViewTypes.GPIO):
print("------------GEAR-------------")
print(" " + str(telemetry_data.current_gear))
print("------------------------------")
self.gpio.update_all(telemetry_data)
elif (self.view_type == ViewTypes.CONSOLE):
os.system('cls' if os.name=='nt' else 'clear')
print("------------------------------")
print("-------------RPM--------------")
print(" " + str(telemetry_data.rpm))
aux = int((telemetry_data.rpm / telemetry_data.max_rpm) * 10)
string_rpm = "----["
for i in range(0,aux):
string_rpm += '**'
for i in range(aux, 10):
string_rpm += ' '
string_rpm += "]----"
print(string_rpm)
print("------------SPEED-------------")
print(" " + str(int(Convert.speed_to_kph(telemetry_data.speed))) + " KPH")
print("------------GEAR-------------")
print(" " + str(telemetry_data.current_gear))
print("------------------------------")
def check_rechts(pivot, rechts, index=0):
if Convert.convert(rechts[index]) > Convert.convert(pivot[index]):
return True
if rechts.lower() == pivot.lower():
if ord(rechts[0]) < ord(pivot[0]):
return False
elif ord(rechts[0]) > ord(pivot[0]):
return True
else:
return False
try:
if Convert.convert(rechts[index]) == Convert.convert(pivot[index]):
return check_rechts(pivot, rechts, index + 1)
except IndexError:
if len(rechts) < len(pivot):
return False
else:
return True
else:
return False
def generate_structure(self, structure, x):
if structure["type"] == "column":
height = random.randint(structure["minheight"], structure["maxheight"])
for y in range(self.heights[x] - height, self.heights[x]):
self.blocks[y][x] = World.get_block(structure["block"])
elif structure["type"] == "json":
structure_file = open(structure["location"])
structure_json = json.load(structure_file)
curr_y = self.heights[x] - len(structure_json["shape"])
for line in structure_json["shape"]:
curr_world_x = Convert.chunk_to_world(x, self)
for char in line:
#find the right chunk
chunk = self #world.chunks[Convert.world_to_chunk(x)[1]]- can't really do this...
curr_chunk_x = Convert.world_to_chunk(curr_world_x)[0]
if curr_chunk_x < WIDTH:
if char == " ":
block = "water"
else:
block = structure_json["blocks"][char]
chunk.blocks[curr_y][curr_chunk_x] = World.get_block(block)
curr_world_x += 1
curr_y += 1
structure_file.close()
elif structure["type"] == "other":
#why did I write this?
pass
def generate_structure(self, structure, x):
#TODO: add background blocks defined separately
if structure["type"] == "column":
height = random.randint(structure["minheight"], structure["maxheight"])
for y in range(self.heights[x] - height, self.heights[x]):
self.set_block_at(x, y, World.get_block(structure["block"]), False)
elif structure["type"] == "json":
structure_file = open(structure["location"])
structure_json = json.load(structure_file)
curr_y = self.heights[x] - len(structure_json["shape"])
for line in structure_json["shape"]:
curr_world_x = Convert.chunk_to_world(x, self)
for char in line:
#find the right chunk
chunk = self #world.chunks[Convert.world_to_chunk(x)[1]]- can't really do this...
curr_chunk_x = Convert.world_to_chunk(curr_world_x)[0]
if curr_chunk_x < WIDTH:
if char == " ":
block_name = "water"
else:
block_name = structure_json["blocks"][char]
block = World.get_block(block_name)
#TODO: add background
chunk.set_block_at(curr_chunk_x, curr_y, block, False)
if block["entity"] != "":
#generate the block entity
EntityClass = getattr(importlib.import_module("ent." + block["entity"]), block["entity"])
instance = EntityClass([curr_world_x, curr_y], self)
self.entities.append(instance)
curr_world_x += 1
curr_y += 1
structure_file.close()
elif structure["type"] == "singleblock":
self.set_block_at(x, self.heights[x] - 1, World.get_block(structure["block"]), False)
def __init__(self, master, typeOfUnit):
self.setType(typeOfUnit)
self.start = 0
self.master = master
self.menubar = Menu(master)
self.unitmenu = Menu(self.menubar, tearoff=0)
self.en = Entry(master, width=30)
self.en.grid(columnspan=10, sticky="N")
t = 0
r = 1
for i in range(Convert.numberOfUnits(self.ty)):
self.unitmenu.add_command(label=Convert.unitName(self.ty, i),
command=partial(self.toChange, i))
self.button = Button(master,
height=2,
width=5,
text=Convert.unitName(self.ty, i),
command=partial(self.changeType, i))
self.button.grid(row=r, column=i - (r - 1) * 4)
if t > 2:
t = 0
r += 1
else:
t += 1
self.menubar.add_cascade(label="start unit", menu=self.unitmenu)
master.config(menu=self.menubar)
self.label = Label(self.master)
def CBC_Mode_Encryption(file_name, key=[], key_len=10, block_size=1):
res = ''
init_vec = random.randrange(1, 2**(block_size * 8))
print init_vec
cur_vec = init_vec
with open(file_name, 'r') as f:
data = f.read()
if len(data) % block_size != 0:
data += '=' * (block_size - len(data) % block_size)
if key == []:
key = []
for _ in range(key_len):
key.append(random.randrange(1, 25))
else:
key_len = len(key)
key_idx = 0
for idx in range(len(data) / block_size):
tmp = int(
Convert.to_bin(data[idx * block_size:(idx + 1) * block_size]), 2)
tmp ^= cur_vec
tmp = bin(tmp)[2:]
tmp = '0' * (8 * block_size - len(tmp)) + tmp
tmp = Convert.to_str(tmp)
temp = ''
for char in tmp:
char = ord(char) + key[key_idx % key_len]
temp += chr(char % 256)
key_idx += 1
cur_vec = int(Convert.to_bin(temp), 2)
res += temp
with open(file_name[:-4] + "_cipher.txt", 'wb') as f:
f.write(res)
return (init_vec, key)
def test_add_superscript(self):
self.assertEqual("", Convert.wrap_checkedToneChar_with_superscript(""))
self.assertEqual(u"^入^",
Convert.wrap_checkedToneChar_with_superscript(u"入"))
self.assertEqual(u"^入^^日^",
Convert.wrap_checkedToneChar_with_superscript(u"入日"))
self.assertEqual(u"江^入^^日^",
Convert.wrap_checkedToneChar_with_superscript(u"江入日"))
def break_block(self, player, mouse_pos, viewport):
angle = self.find_angle(player, mouse_pos, viewport)
block_pos = Convert.pixels_to_world(self.find_pos(angle, player.pixel_pos(True), Convert.viewport_to_pixels(mouse_pos, viewport), player.get_break_distance())) #it aint right
chunk = self.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1])
block = self.get_block(block_pos)
if block["breakable"]:
chunk.blocks[block_pos[1]][Convert.world_to_chunk(block_pos[0])[0]] = get_block("water")
chunk.entities.append(BlockDrop.BlockDrop(block_pos, block["name"]))
def update(self):
for x in range(self.loaded_chunks.first, self.loaded_chunks.end):
chunk = self.loaded_chunks.get(x)
for entity in chunk.entities:
entity.update(self)
if Convert.world_to_chunk(entity.pos[0])[1] != chunk.x:
print("Moving", entity, entity.pos)
chunk.entities.remove(entity)
self.loaded_chunks.get(Convert.world_to_chunk(entity.pos[0])[1]).entities.append(entity)
def render_break_preview(self, background, world, block, block_pos, screen, viewport):
chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1])
blockimg = world.get_block_render(World.get_block_id(block["name"]), block_pos, block["connectedTexture"], background, chunk, background).copy()
mask = pygame.mask.from_surface(blockimg)
olist = mask.outline()
polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA)
color = self.get_color(background)
pygame.draw.polygon(polysurface, color, olist, 0)
screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport))
def feature_extraction_L1_L0(parameter_rho_coef, parameter_gamma, parameter_mu,
S0, D, itr, thr, lay):
S0 = 2 * S0
S0 -= np.mean(S0, axis=(0, 1))
S = S0
cri = cr.CSC_ConvRepIndexing(D, S)
dsz = D.shape
X = the_minimum_l2_norm_solution(D, S, cri)
parameter_sigma = setting_sigma(X)
Df = con.convert_to_Df(D, S, cri)
Xstep_iteration = itr[0]
total_iteration = itr[2]
bar_Lay = tqdm(total=len(parameter_sigma), desc=lay, leave=False)
for k in parameter_sigma:
bar_L = tqdm(total=total_iteration, desc='L', leave=False)
for L in range(total_iteration):
nabla_x = nabla_x_create(X, k)
X = X - parameter_mu * nabla_x
if ((k == parameter_sigma[0]) & (L == 0)):
Xf = con.convert_to_Xf(X, S, cri)
Df = con.convert_to_Df(D, S, cri)
XfDf = np.sum(Xf * Df, axis=cri.axisM)
XD = con.convert_to_S(XfDf, cri)
Y = XD - S
U = np.zeros(S.shape)
X, Y, U = projection_to_solution_space_by_L1(
D, X, S, Y, U, parameter_rho_coef, parameter_gamma,
Xstep_iteration, thr, cri, dsz)
if (np.sum(X != 0) == 0):
bar_L.update(total_iteration - L)
break
bar_L.update(1)
bar_L.close()
if (np.sum(X != 0) == 0):
bar_Lay.update(len(parameter_sigma) - k)
break
bar_Lay.update(1)
#X = np.where((-parameter_sigma[-1] < X) & (X < parameter_sigma[-1]), 0, X)
bar_Lay.close()
l0_norm = np.sum(X != 0)
print("[" + lay + "] L0 norm: %d " % l0_norm)
return X, l0_norm
def render(self, screen, pos):
if self.animating:
old_pixel_pos = Convert.world_to_pixels(self.old_pos)
new_pixel_pos = Convert.world_to_pixels(self.pos)
animation_ratio = 1 - (self.animation_stage / EntityPuzzlePiece.ANIMATION_MAX)
difference = ((old_pixel_pos[0] - new_pixel_pos[0]) * animation_ratio,
(old_pixel_pos[1] - new_pixel_pos[1]) * animation_ratio)
screen.blit(self.img, (pos[0] + difference[0], pos[1] + difference[1]))
else:
screen.blit(self.img, pos)
def __init__(self):
# holds all kinds of data about SOSS status aliases
self.info = Convert.statusInfo()
# statusConverter object, used to extract and interpret SOSS
# values in the tables
self.conv = Convert.statusConverter()
super(baseSOSSstatusObj, self).__init__()
def __init__(self, pos, imageurl, scale=()):
self.pos = pos
self.imageurl = imageurl
self.scale = scale
self.load_image()
#bounding box is in pixels because it can only have ints
self.bounding_box = pygame.Rect(Convert.world_to_pixel(pos[0]), Convert.world_to_pixel(pos[1]), self.img.get_width(), self.img.get_height())
self.width = Convert.pixel_to_world(self.img.get_width()) + 1
self.height = Convert.pixel_to_world(self.img.get_height()) + 1
self.dir = [0, 0] #direction: -1, 0, 1
self.vel = [0, 0] #speeds: any numbers
def render_block(self, block, pos, screen, viewport):
"""#fast render water
if block["name"] == "water":
screen.blit(World.block_images[block["id"]],
Convert.world_to_viewport([Convert.chunk_to_world(pos[0], self), pos[1]], viewport))"""
#don't render air
if block["name"] != "air":
#print(block["name"] + " " + str(block["id"]))
Game.get_world().render_block(block["id"], [Convert.chunk_to_world(pos[0], self), pos[1]], block["connectedTexture"], screen, viewport)
if Game.DEBUG:
#draw bounding box
pygame.draw.rect(screen, Game.BLACK, pygame.Rect(Convert.chunk_to_viewport(pos, self, viewport), (Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE)), 1)
def tentative_move(self, world, old_pos, index):
self.pos[index] += self.vel[index]
if index == 0:
self.bounding_box.x = Convert.world_to_pixel(self.pos[index])
else:
self.bounding_box.y = Convert.world_to_pixel(self.pos[index])
block_left = int(Convert.world_to_chunk(self.pos[0])[0])
chunk_left = Convert.world_to_chunk(self.pos[0])[1]
block_right = math.ceil(Convert.world_to_chunk(self.pos[0] + self.width)[0])
chunk_right = Convert.world_to_chunk(self.pos[0] + self.width)[1]
block_top = int(self.pos[1])
block_bottom = math.ceil(self.pos[1] + self.height)
col1 = col2 = col3 = col4 = False
if chunk_left == chunk_right:
chunk = world.loaded_chunks.get(chunk_left)
col1 = self.check_collision(chunk, block_left, block_right, block_top, block_bottom, old_pos, index)
else:
#need to check from block_left in chunk_left to block_right in chunk_right and all the blocks in any chunks between them
chunk = world.loaded_chunks.get(chunk_left)
col2 = self.check_collision(chunk, block_left, Chunk.WIDTH, block_top, block_bottom, old_pos, index)
for c in range(chunk_left + 1, chunk_right):
chunk = world.loaded_chunks.get(c)
col3 = self.check_collision(chunk, 0, Chunk.WIDTH, block_top, block_bottom, old_pos, index)
chunk = world.loaded_chunks.get(chunk_right)
col4 = self.check_collision(chunk, 0, block_right, block_top, block_bottom, old_pos, index)
if col1 or col2 or col3 or col4:
self.vel[index] = 0 #reset acceleration?
if index == 0:
self.bounding_box.x = Convert.world_to_pixel(self.pos[index])
else:
self.bounding_box.y = Convert.world_to_pixel(self.pos[index])
def dictionary_learning_by_L1_Dstep(Xf, S, G1, H1, G0, H0, parameter_rho_dic,
iteration, cri, dsz):
GH = con.convert_to_Df(G1 - H1, S, cri)
GSH = con.convert_to_Sf(G0 + S - H0, cri)
b = GH + sl.inner(np.conj(Xf), GSH, cri.axisK)
Df = sl.solvemdbi_ism(Xf, 1, b, cri.axisM, cri.axisK)
D = con.convert_to_D(Df, dsz, cri)
XfDf = np.sum(Xf * Df, axis=cri.axisM)
XD = con.convert_to_S(XfDf, cri)
G0 = sp.prox_l1(XD - S + H0, (1 / parameter_rho_dic))
H0 = H0 + XD - G0 - S
return D, G0, H0, XD
def render_blocks(self, screen, viewport, background):
top = max(Convert.pixel_to_world(viewport.y), 0)
bottom = min(Convert.pixel_to_world(viewport.y + viewport.height) + 1, World.HEIGHT - 1)
for blocky in range(top, bottom):
leftData = Convert.pixel_to_chunk(viewport.x)
rightData = Convert.pixel_to_chunk(viewport.x + viewport.width)
if leftData[1] == self.x:
for blockx in range(leftData[0], WIDTH):
self.render_block(blockx, blocky, screen, viewport, background)
elif leftData[1] < self.x < rightData[1]:
for blockx in range(WIDTH):
self.render_block(blockx, blocky, screen, viewport, background)
elif self.x == rightData[1]:
for blockx in range(0, rightData[0] + 1):
self.render_block(blockx, blocky, screen, viewport, background)
def projection_to_solution_space_by_L2(D, X, S, parameter_gamma, iteration,
thr, cri, dsz):
Df = con.convert_to_Df(D, S, cri)
Xf = con.convert_to_Xf(X, S, cri)
for i in range(iteration):
Sf = con.convert_to_Sf(S, cri)
b = (1 / parameter_gamma) * Xf + np.conj(Df) * Sf
Xf = sl.solvedbi_sm(Df, (1 / parameter_gamma), b)
X = con.convert_to_X(Xf, cri)
Xf = con.convert_to_Xf(X, S, cri)
return X
def show(config):
images1 = Convert.loadImages(config.deployImages)[config.segmentRange]
images2 = Convert.loadImages(config.deployLabels)[config.segmentRange]
start = min(config.segmentRange) - min(config.deployRange)
images3 = np.load(config.likelihood)[start:, :, :, 1]
images4 = Convert.loadMHA(glob.glob(config.getResultFile("final_*.mha")))
def press(event):
global curr_pos
# use keyboard to change images
if event.key == "right":
curr_pos = (curr_pos + 1) % images3.shape[0]
elif event.key == "left":
curr_pos = (curr_pos - 1) % images3.shape[0]
show()
def show():
fig.clear()
plt.subplot(2, 2, 1)
plt.title("Origin")
plt.imshow(images1[curr_pos], cmap="Greys_r")
plt.axis('off')
plt.subplot(2, 2, 2)
plt.title("Labels")
plt.imshow(images2[curr_pos], cmap="Greys_r")
plt.axis('off')
plt.subplot(2, 2, 3)
plt.title("CNN Result")
plt.imshow(images3[curr_pos], cmap="Greys_r")
plt.axis('off')
plt.subplot(2, 2, 4)
plt.title("Segment Result")
plt.imshow(images4[curr_pos])
plt.axis('off')
fig.suptitle("Image " + str(config.segmentRange[curr_pos] + 1))
fig.canvas.draw()
fig = plt.figure(figsize=(12, 8))
fig.canvas.mpl_connect('key_press_event', press)
show()
plt.show()
def main():
print("Valikko")
style1()
print("(1).Luo tiedosto")
print("(2).Etsi tiedostosta")
print("(3).Kirjoita tiedostoon")
print("(4).Poista tiedosto")
print("(5).Kopioi tiedosto")
print("(6).Konvertoi kuvat")
print("(7).test zip")
style1()
myInput = input("Valitse numero: ")
if len(myInput) <= 0:
pass
elif len(myInput) >= 30:
print("liika")
elif myInput == "1":
luoTiedosto()
elif myInput == "2":
SeachFile()
elif myInput == "3":
tiedostot()
elif myInput == "4":
pythonFile.poistaTiedosto()
elif myInput == "5":
copyFile()
elif myInput == "6":
Convert.ConvertImages()
elif myInput == "7":
testMe.zip()
def render_actual(self, screen):
index = int((self.max_decay - self.decay) / FRAME_LENGTH)
#self.load_image()
img = self.imgs[index] #TODO: these might all be dead surfaces if loading in
pos = Convert.world_to_viewport(self.pos, Game.get_viewport())
center = img.get_rect().center
screen.blit(img, (pos[0] - center[0], pos[1] - center[1]))
def update(self, world):
old_chunk = Convert.world_to_chunk(self.pos[0])[1]
hspeed = min(abs(self.vel[0] + self.acceleration * self.dir[0]), self.max_speed) * self.dir[0]
vspeed = min(abs(self.vel[1] + self.acceleration * self.dir[1]), self.max_speed) * self.dir[1]
self.vel = [hspeed, vspeed]
super(Player, self).update(world)
new_chunk = Convert.world_to_chunk(self.pos[0])[1]
if new_chunk != old_chunk:
world.load_chunks(new_chunk)
entities = self.get_nearby_entities(world)
for entity in entities:
if(self.bounding_box.colliderect(entity.bounding_box)):
if isinstance(entity, ItemDrop):
if self.inventory.insert(entity.get_itemstack()) == None:
world.loaded_chunks.get(entity.get_chunk()).entities.remove(entity)
def convert(src, tgt, txt, nativize, preoptions, postoptions):
txt = PreProcess.PreProcess(txt, src, tgt)
if 'siddhamUnicode' in postoptions and tgt == 'Siddham':
tgt = 'SiddhamUnicode'
if 'LaoNative' in postoptions and tgt == 'Lao':
tgt = 'Lao2'
if 'siddhamUnicode' in preoptions and src == 'Siddham':
src = 'SiddhamUnicode'
if 'egrantamil' in preoptions and src == 'Grantha':
src = 'GranthaGrantamil'
if 'egrantamil' in postoptions and tgt == 'Grantha':
tgt = 'GranthaGrantamil'
for options in preoptions:
txt = getattr(PreProcess, options)(txt)
transliteration = Convert.convertScript(txt, src, tgt)
if nativize:
transliteration = PostOptions.ApplyScriptDefaults(
transliteration, src, tgt)
if tgt != 'Tamil':
transliteration = PostProcess.RemoveDiacritics(transliteration)
else:
transliteration = PostProcess.RemoveDiacriticsTamil(
transliteration)
for options in postoptions:
transliteration = getattr(PostProcess, options)(transliteration)
return transliteration
def use_discrete(self, world, player, mouse_pos, viewport):
#TODO: different types of projectile
pos = player.pos[:]
pixel_player_pos = Convert.world_to_viewport(pos, viewport)
difference = (mouse_pos[0] - pixel_player_pos[0],
mouse_pos[1] - pixel_player_pos[1])
length = math.sqrt(difference[0] ** 2 + difference[1] ** 2)
normalized = [difference[0] / length * ToolMagicStaff.PROJECTILE_SPEED,
difference[1] / length * ToolMagicStaff.PROJECTILE_SPEED]
vel = [player.vel[0] + normalized[0],
player.vel[1] + normalized[1]]
damage_source = DamageSourceBullet(pos, 5, 0.5, vel, "img/projectiles/orb.png", player, 60)
world.create_entity(damage_source)
world.create_entity(EntityEnemy(Convert.viewport_to_world(mouse_pos, viewport), "img/enemies/pinky.png", 10)) #TODO: remove
def dictionary_learning_by_L1(X, S, dsz, G1, H1, G0, H0, parameter_rho_dic,
iteration, thr, cri):
Xf = con.convert_to_Xf(X, S, cri)
bar_D = tqdm(total=iteration, desc='D', leave=False)
for i in range(iteration):
D, G0, H0, XD = dictionary_learning_by_L1_Dstep(
Xf, S, G1, H1, G0, H0, parameter_rho_dic, i, cri, dsz)
Dr = np.asarray(D.reshape(cri.shpD), dtype=S.dtype)
H1r = np.asarray(H1.reshape(cri.shpD), dtype=S.dtype)
Pcn = cr.getPcn(dsz, cri.Nv, cri.dimN, cri.dimCd)
G1r = Pcn(Dr + H1r)
G1 = cr.bcrop(G1r, dsz, cri.dimN).squeeze()
H1 = H1 + D - G1
Est = sp.norm_l1(XD - S)
if (i == 0):
pre_Est = 1.1 * Est
if ((pre_Est - Est) / pre_Est <= thr):
bar_D.update(iteration - i)
break
pre_Est = Est
bar_D.update(1)
bar_D.close()
return D, G0, G1, H0, H1
def main():
print("Jay Ganesh....")
print("Enter Character To Convert")
ch = input()
Convert.Convert(ch)
def render_block(self, x, y, screen, viewport, background):
#don't render air
if background:
block = World.get_block_from_id(self.background_blocks[y][x])
else:
block = World.get_block_from_id(self.foreground_blocks[y][x])
if block["name"] != "air":
Game.get_world().render_block(block["id"], [Convert.chunk_to_world(x, self), y], block["connectedTexture"], screen, viewport, background, self)
def update(self, world):
old_chunk = Convert.world_to_chunk(self.pos[0])[1]
hspeed = min(abs(self.vel[0] + self.acceleration * self.dir[0]), self.max_speed) * self.dir[0]
vspeed = min(abs(self.vel[1] + self.acceleration * self.dir[1]), self.max_speed) * self.dir[1]
self.vel = [hspeed, vspeed]
super(Player, self).update(world)
new_chunk = Convert.world_to_chunk(self.pos[0])[1]
if new_chunk != old_chunk:
world.load_chunks(new_chunk)
entities = world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1]).entities
for entity in entities:
if(self.bounding_box.colliderect(entity.bounding_box)):
if type(entity) is BlockDrop:
if self.pickup(entity.blockname):
entities.remove(entity)
print(self.inventory)
def render(self, screen, viewport):
top = max(Convert.pixel_to_world(viewport.y), 0)
bottom = min(Convert.pixel_to_world(viewport.y + viewport.height) + 1, World.HEIGHT)
for blocky in range(top, bottom):
leftData = Convert.pixel_to_chunk(viewport.x)
rightData = Convert.pixel_to_chunk(viewport.x + viewport.width)
if leftData[1] == self.x:
for blockx in range(leftData[0], WIDTH):
self.render_block(self.blocks[blocky][blockx], (blockx, blocky), screen, viewport)
elif leftData[1] < self.x < rightData[1]:
for blockx in range(WIDTH):
self.render_block(self.blocks[blocky][blockx], (blockx, blocky), screen, viewport)
elif self.x == rightData[1]:
for blockx in range(0, rightData[0] + 1):
self.render_block(self.blocks[blocky][blockx], (blockx, blocky), screen, viewport)
for entity in self.entities:
entity.render(screen, Convert.world_to_viewport(entity.pos, viewport))
def get_page_data(titles, hyperlinks):
options = webdriver.ChromeOptions()
options.add_argument('--ignore-certificate-errors')
options.add_argument("--test-type")
options.add_argument('--no-sandbox')
options.add_argument('–disable-dev-shm-usage')
driver = webdriver.Chrome('C:/ChromeDriver/chromedriver.exe', chrome_options=options)
browser = webdriver.Chrome(executable_path='C:/ChromeDriver/chromedriver.exe', chrome_options=options)
page_data = {'country': [], 'genre': [], 'budget': [], 'awards': [], 'award wins': [], 'award nominations': [],
'duration': []}
index = 1
for hyperlink, title in zip(hyperlinks, titles):
browser.get(hyperlink)
# Wait 20 seconds for page to load
timeout = 20
try:
WebDriverWait(browser, timeout).until(EC.visibility_of_element_located((By.TAG_NAME, 'h1')))
except TimeoutException:
print("Timed out waiting for page to load")
browser.quit()
a = browser.find_element_by_css_selector("div[class='subtext']").text
meta_info = a.split(' | ')
duration = meta_info[1]
genre = meta_info[2]
try:
country = browser.find_element_by_xpath("//h4[contains(text(), 'Country')]/following-sibling::a").text
except NoSuchElementException:
country = "Unknown"
try:
budget = browser.find_element_by_xpath("//h4[contains(text(), 'Budget')]/..").text[7:-12]
except NoSuchElementException:
budget = "Unknown"
converted_budget = Convert.convert_currency(budget)
try:
awards = browser.find_element_by_css_selector("span[class='awards-blurb']").text
extract_wins_nominations(awards, page_data)
except NoSuchElementException:
awards = "0"
page_data['award wins'].append('0')
page_data['award nominations'].append('0')
print(str(index) + " " + title)
index += 1
# print("country: " + country)
page_data['country'].append(country)
# print("duration: " + duration)
page_data['duration'].append(duration)
# print("genre: " + genre)
page_data['genre'].append(genre)
# print("budget: " + budget)
page_data['budget'].append(converted_budget)
# print("awards: " + awards + "\n")
page_data['awards'].append(awards)
browser.quit()
return page_data
def __init__(self,
logger,
statusObj,
threadPool,
ev_quit=None,
myhost=None,
monchannels=[],
loghome=None):
self.recvTSCTasker = self.processRpcMsgTasker(
self.processTCSstatRpcMsg)
self.recvSOSSTasker = self.processRpcMsgTasker(
self.processSOSSstatRpcMsg)
self.recvDAQTasker = self.processRpcMsgTasker(self.processDAQgetRpcMsg)
self.statusObj = statusObj
self.num_SOSSmonunits = 5
self.num_TSCmonunits = 1
self.TSCmonunit = {}
self.SOSSmonunit = {}
self.ScreenGet = {}
self.statusInfo = Convert.statusInfo(version=2)
# For TSC status logging
self.loghome = loghome
self.tsclog = {}
self.tsclog_lock = threading.RLock()
self.tsclog_hr = 0
self.logger = logger
self.monitor = None
self.threadPool = threadPool
self.monchannels = monchannels
if ev_quit:
self.ev_quit = ev_quit
else:
self.ev_quit = threading.Event()
self.timeout = 0.1
self.qtask = None
self.taskqueue = Queue.Queue()
# For handling updates to the monitor
self.monUpdateInterval = 1.0
self.monUpdateSet = set([])
self.monUpdateLock = threading.RLock()
# For DAQ status request handing
self.hostfilter = None
self.hostfilter_lock = threading.RLock()
if not myhost:
myhost = SOSSrpc.get_myhost(short=True)
self.myhost = myhost
self.seq_num = SOSSrpc.rpcSequenceNumber()
self.clients = {}
self.client_lock = threading.RLock()
# For task inheritance:
self.tag = 'StatusReceiver'
self.shares = ['logger', 'ev_quit', 'timeout', 'threadPool', 'monitor']
def render():
if gamemode == MAINMENU or gamemode == PAUSEMENU:
menu.render_background(screen)
menu.render(screen)
elif gamemode in (PLAYING, OPENGUI):
player = world.player
shift = pygame.key.get_pressed()[pygame.K_LSHIFT] or pygame.key.get_pressed()[pygame.K_RSHIFT]
screen.fill(SKY)
#background
world.render(screen, viewport, True)
if shift:
player.draw_block_highlight(world, pygame.mouse.get_pos(), viewport, screen, shift)
world.render_breaks(screen, viewport, True)
#foreground
world.render(screen, viewport, False)
if not shift:
player.draw_block_highlight(world, pygame.mouse.get_pos(), viewport, screen, shift)
world.render_breaks(screen, viewport, False)
player.render(screen, Convert.world_to_viewport(player.pos, viewport))
#add blue overlay- not completely sure this is good
overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
overlay.set_alpha(64)
overlay.fill(BLUE)
screen.blit(overlay, (0, 0))
if gamemode == PLAYING:
hotbarGui.render(screen)
else:
gui.render(screen)
if DEBUG:
#render debug text
chunk = world.loaded_chunks.get(Convert.world_to_chunk(player.pos[0])[1])
debugtext = ["fps: {0:.2f}".format(clock.get_fps()),
"pos: [{0:.2f}".format(player.pos[0]) + ", {0:.2f}]".format(player.pos[1]),
"chunk: " + str(chunk.x),
"biome: " + str(chunk.biome["name"])]
debugimg = GUI.render_string_array(debugtext, font, 0, WHITE)
h = SCREEN_HEIGHT - debugimg.get_height()
screen.blit(debugimg, (2 * SCALE, h))
pygame.display.flip()
def update(self):
for x in range(self.loaded_chunks.first, self.loaded_chunks.end):
chunk = self.loaded_chunks.get(x)
for entity in chunk.entities:
entity.update(self)
if Convert.world_to_chunk(entity.pos[0])[1] != chunk.x \
and self.loaded_chunks.contains_index(Convert.world_to_chunk(entity.pos[0])[1]) \
and entity in chunk.entities:
chunk.entities.remove(entity)
self.create_entity(entity)
for layer in [True, False]:
blocks_to_remove = []
for breaking_block in self.breaking_blocks[layer]:
breaking_block["progress"] -= 1
if breaking_block["progress"] <= 0:
blocks_to_remove.append(breaking_block)
for b in blocks_to_remove:
self.breaking_blocks[layer].remove(b)
def check_collision(self, chunk, left, right, top, bottom, old_pos, index):
for block_x in range(left, right):
for block_y in range(top, bottom):
check_block = World.get_block(chunk.get_block_at(block_x, block_y, self.background))
if check_block["solid"] and self.collides([Convert.chunk_to_world(block_x, chunk), block_y]):
#found a collision!
self.pos[index] = old_pos[index]
return True
return False
def update():
for event in pygame.event.get():
if event.type == pygame.QUIT:
close()
elif event.type == pygame.MOUSEBUTTONDOWN:
if gamemode == MENU:
menu.mouse_press()
if gamemode == PLAYING:
world.break_block(player, pygame.mouse.get_pos(), viewport)
elif event.type == pygame.MOUSEBUTTONUP:
if gamemode == MENU:
menu.mouse_release()
elif event.type == pygame.KEYDOWN:
if pygame.key.get_pressed()[pygame.K_e]:
global gui
if gui is None:
gui = InventoryGUI.InventoryGUI(player)
else:
gui = None
if pygame.key.get_pressed()[pygame.K_F3]:
global DEBUG
DEBUG = not DEBUG
pressed = pygame.key.get_pressed()
if pressed[pygame.K_ESCAPE]:
close()
if gamemode == MENU:
menu.update()
elif gamemode == PLAYING:
player.dir = [0, 0]
if pressed[pygame.K_LEFT] or pressed[pygame.K_a]:
player.dir[0] -= 1
if pressed[pygame.K_RIGHT] or pressed[pygame.K_d]:
player.dir[0] += 1
if pressed[pygame.K_UP] or pressed[pygame.K_w]:
player.dir[1] -= 1
if pressed[pygame.K_DOWN] or pressed[pygame.K_s]:
player.dir[1] += 1
player.update(world)
viewport.x = Convert.world_to_pixels(player.pos)[0] - SCREEN_WIDTH / 2 #replace with center
viewport.y = Convert.world_to_pixels(player.pos)[1] - SCREEN_HEIGHT / 2
world.update()
def check_collision(self, chunk, left, right, top, bottom, old_pos, index):
for block_x in range(left, right):
for block_y in range(top, bottom):
check_block = chunk.blocks[block_y][block_x]
#if check_block.is_solid() and self.collides([Convert.chunk_to_world(block_x, chunk), block_y]):
if check_block["solid"] and self.collides([Convert.chunk_to_world(block_x, chunk), block_y]):
#found a collision!
self.pos[index] = old_pos[index]
return True
return False
def render_block_preview(self, background, held_item, world, block_pos, screen, viewport):
held_block = World.get_block(held_item.name)
blockimg = world.get_block_render(World.get_block_id(held_block["name"]), block_pos, held_block["connectedTexture"], background, background).copy()
mask = pygame.mask.from_surface(blockimg)
olist = mask.outline()
polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA)
screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport))
collides = False
entities = self.get_nearby_entities(world)
entities.append(self)
for entity in entities:
if entity.collides(block_pos) and entity.background == background:
collides = True
color = self.get_color(background)
if collides and World.get_block(held_block["name"])["solid"]:
color = (color[0], 0, 0, color[3])
pygame.draw.polygon(polysurface, color, olist, 0)
blockimg.blit(polysurface, (0, 0), special_flags=pygame.BLEND_RGBA_MULT)
screen.blit(blockimg, Convert.world_to_viewport(block_pos, viewport))
def render_breaks(self, screen, viewport, background):
for breaking_block in self.breaking_blocks[background]:
break_index = int(breaking_block["progress"] / breaking_block["breaktime"] * Game.BREAK_LENGTH)
breakimg = Images.break_images[break_index].copy()
blockimg = block_images[False][get_block_id(breaking_block["name"])] #TODO: make this support CTM
mask = pygame.mask.from_surface(blockimg)
olist = mask.outline()
polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA)
pygame.draw.polygon(polysurface, Game.WHITE, olist, 0)
breakimg.blit(polysurface, (0, 0), special_flags=pygame.BLEND_RGBA_MULT)
screen.blit(breakimg, Convert.world_to_viewport(breaking_block["pos"], viewport))
def is_clear(self, world, pos):
for x in range(int(pos[0]), int(pos[0] + self.width)):
for y in range(int(pos[1]), int(pos[1] + self.height)):
if not world.is_loaded_chunk(Convert.world_to_chunk(x)[1]):
return False
if y >= World.HEIGHT:
return False
block = World.get_block(world.get_block_at((x, y), False))
if block["solid"]:
return False
return True
def update_file():
parser = argparse.ArgumentParser(
description='Generate a classic book with the desired format.')
parser.add_argument('sort', type=str, help='simplified or tranditional')
parser.add_argument('book', type=str, help='a book file')
args = parser.parse_args()
filePath = args.book
sort = args.sort
try:
content = None
with open(filePath, 'r') as file:
content = file.read().decode("utf-8")
if sort == 'Simplified':
content = Convert.Convert(content)
else:
content = Convert.wrap_checkedToneChar_with_superscript(content)
with open(filePath, 'w') as file:
file.write(content.encode("utf-8"))
except IOError:
print("IOError occurs while handling the file (" + filePath + ").")
def changeType(self, newType):
number = self.en.get()
self.label.destroy()
try:
number = float(number)
except:
self.label = Label(self.master, text="type in a number please")
self.label.grid(columnspan=12, sticky="SE")
return False
value = Convert.newUnit(self.ty, number,
Convert.unitName(self.ty, self.start),
Convert.unitName(self.ty, newType))
self.en.delete(0, 20)
self.label = Label(self.master,
height=3,
text=str(value) + " " +
Convert.unitName(self.ty, newType))
self.label.grid(columnspan=12, sticky="SE")
def segment(config):
# images = Convert.loadImages(config.trainImages)
# gts = Convert.convertLabels(Convert.loadImages(config.trainLabels))
# probs = np.load(config.likelihood) * 256
images = Convert.loadImages(config.trainImages)
gts = _getGroundTrues(Convert.loadImages(config.trainLabels))
probs = Convert.loadImages(config.likelihood)
RandIndex = np.zeros(probs.shape[0])
VOI = np.zeros(probs.shape[0])
RE = np.zeros(probs.shape[0])
for i in range(probs.shape[0]):
pr = probs[i]
temp = np.zeros((pr.shape[0] + 2, pr.shape[1] + 2))
temp[1:pr.shape[0] + 1, 1:pr.shape[1] + 1] = pr[:, :]
pr = temp
pr = ndimage.gaussian_filter(pr, sigma=5, mode="constant")
thres = 0.03
itk.Water
class WinApp(Tk):
def __init__(self):
Tk.__init__(self)
self.bind('<Destroy>',self.__onDestory)
self.startBtn = Button(self,text = "START",command = self.__startFn)
self.startBtn.pack()
self.stopBtn = Button(self,text = "STOP",command = self.__stopFn)
self.stopBtn.pack()
self.__createWidget()
self.t = threading.Thread(target = self.__running)
self.__stop = False
self.__terminate = False
self.t.start()
def __onDestory(self,evnet):
self.inComm.terminate()
self.outComm.terminate()
self.__terminate = True
def __createWidget(self):
self.inComm = Comm("COM4",57600)
self.outComm = Comm("COM5",57600)
self.inComm.start()
self.outComm.start()
self.conv = Convert(23,1.21,0)
def __startFn(self):
ret,msg = self.inComm.open()
ret,msg = self.outComm.open()
self.__stop = False
def __stopFn(self):
self.__stop = True
time.sleep(0.5)
self.inComm.close()
self.outComm.close()
def __running(self):
while not self.__terminate:
if self.__stop:
continue
ret,data = self.inComm.recv(3)
if not ret:
continue
ret,data = self.conv.conv(data)
if not ret:
continue
self.outComm.send((str(data)+'\n').encode('utf8'))
def break_block(self, world, mouse_pos, viewport, background):
block_pos = self.find_angle_pos(mouse_pos, viewport)
chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1])
#if there's a foreground block covering the background, don't break anything
if background and world.get_block_at(block_pos, False) != "water":
return
block = World.get_block(world.get_block_at(block_pos, background))
held_item = self.get_held_item()
if held_item is None:
harvest_level = 0
break_speed = 1
else:
harvest_level = held_item.get_harvest_level()
break_speed = held_item.get_break_speed()
if (not block["breakable"]) or (block["harvestlevel"] > harvest_level):
return
block_to_break = None
breaking_blocks = world.breaking_blocks[background]
for breaking_block in breaking_blocks:
if breaking_block["pos"] == block_pos:
block_to_break = breaking_block
if block_to_break is None:
block_to_break = {"pos": block_pos, "name": block["name"], "progress": 0, "breaktime": block["breaktime"]}
breaking_blocks.append(block_to_break)
block_to_break["progress"] += 2 * break_speed
if block_to_break["progress"] >= block_to_break["breaktime"]:
#remove the block
breaking_blocks.remove(block_to_break)
chunk.set_block_at(Convert.world_to_chunk(block_pos[0])[0], block_pos[1], World.get_block("water"), background)
blockentity = None
if block["entity"] != "":
#remove the associated entity
for entity in chunk.entities:
if type(entity).__name__ == block["entity"] and [int(entity.pos[0]), int(entity.pos[1])] == block_pos:
chunk.entities.remove(entity)
blockentity = entity
break
chunk.entities.append(ItemDrop(block_pos, block["name"], blockentity))
def load_state(self, path):
savefile = open(path, "rb")
save_data = pickle.load(savefile)
savefile.close()
self.player.set_pos(save_data["player_pos"])
player_chunk = Convert.world_to_chunk(self.player.pos[0])[1]
self.loaded_chunks = TwoWayList.TwoWayList()
self.load_chunks(player_chunk)
self.player.inventory = save_data["player_inventory"]
for row in self.player.inventory:
for item in row:
if item is not None:
item.load_image()
self.player.selected_slot = save_data["hotbar_slot"]
def check_links(pivot, links, index=0):
if Convert.convert(links[index]) < Convert.convert(pivot[index]):
return True
if links.lower() == pivot.lower():
if ord(links[0]) > ord(pivot[0]):
return False
elif ord(links[0]) < ord(pivot[0]):
return True
try:
if Convert.convert(links[index]) == Convert.convert(pivot[index]):
return check_links(pivot, links, index + 1)
except IndexError:
if len(links) > len(pivot):
return False
else:
return True
return False
def GetSpheCoordinates(self):
spherical_list = self.entry_3.get() + "," + self.entry_6.get(
) + "," + self.entry_9.get()
print(spherical_list)
if self.entry_1.get() != '':
sphe_list = spherical_list.split(',')
sphe = [float(x.strip()) for x in sphe_list]
rect = Convert.sph_to_cart(sphe[0], sphe[1], sphe[2])
cyli = Convert.sph_to_cyl(sphe[0], sphe[1], sphe[2])
print('Cartesian: (' + "%.4f" % rect[0] + ', ' + "%.4f" % rect[1] +
', ' + "%.4f" % rect[2] + ').')
print('Cylindrical: (' + "%.4f" % cyli[0] + ', ' + "%.4f" % cyli[1] +
', ' + "%.4f" % cyli[2] + ').')
print('Spherical: (' + "%.4f" % sphe[0] + ', ' + "%.4f" % sphe[1] +
', ' + "%.4f" % sphe[2] + ').')
self.entry_1.delete(0, tk.END)
self.entry_1.insert(0, rect[0])
self.entry_4.delete(0, tk.END)
self.entry_4.insert(0, rect[1])
self.entry_7.delete(0, tk.END)
self.entry_7.insert(0, rect[2])
self.entry_2.delete(0, tk.END)
self.entry_2.insert(0, cyli[0])
self.entry_5.delete(0, tk.END)
self.entry_5.insert(0, cyli[1])
self.entry_8.delete(0, tk.END)
self.entry_8.insert(0, cyli[2])
self.x, self.y, self.z = rect[0], rect[1], rect[2]
self.a, self.b, self.c = cyli[0], cyli[1], cyli[2]
self.i, self.j, self.k = sphe[0], sphe[1], sphe[2]
def load_state(self, path):
savefile = open(path, "rb")
save_data = pickle.load(savefile)
savefile.close()
self.player = save_data["player"]
self.seed = save_data["seed"]
Generate.setup(self.seed)
player_chunk = Convert.world_to_chunk(self.player.pos[0])[1]
self.loaded_chunks = TwoWayList.TwoWayList()
self.load_chunks(player_chunk)
self.player.load_image()
for row in self.player.inventory:
for item in row:
if item is not None:
item.load_image()
def GetRectCoordinates(self):
rectangular_list = self.entry_1.get() + "," + self.entry_4.get(
) + "," + self.entry_7.get()
print(rectangular_list)
if self.entry_1.get() != '':
rect_list = rectangular_list.split(',')
rect = [float(x.strip()) for x in rect_list]
cyli = Convert.cart_to_cyl(rect[0], rect[1], rect[2])
sphe = Convert.cart_to_sph(rect[0], rect[1], rect[2])
print('Cartesian: (' + "%.4f" % rect[0] + ', ' + "%.4f" % rect[1] +
', ' + "%.4f" % rect[2] + ').')
print('Cylindrical: (' + "%.4f" % cyli[0] + ', ' + "%.4f" % cyli[1] +
', ' + "%.4f" % cyli[2] + ').')
print('Spherical: (' + "%.4f" % sphe[0] + ', ' + "%.4f" % sphe[1] +
', ' + "%.4f" % sphe[2] + ').')
self.entry_2.delete(0, tk.END)
self.entry_2.insert(0, cyli[0])
self.entry_5.delete(0, tk.END)
self.entry_5.insert(0, cyli[1])
self.entry_8.delete(0, tk.END)
self.entry_8.insert(0, cyli[2])
self.entry_3.delete(0, tk.END)
self.entry_3.insert(0, sphe[0])
self.entry_6.delete(0, tk.END)
self.entry_6.insert(0, sphe[1])
self.entry_9.delete(0, tk.END)
self.entry_9.insert(0, sphe[2])
self.x, self.y, self.z = rect[0], rect[1], rect[2]
self.a, self.b, self.c = cyli[0], cyli[1], cyli[2]
self.i, self.j, self.k = sphe[0], sphe[1], sphe[2]
def convert(src, tgt, txt, nativize, preoptions, postoptions):
txt = PreProcess.PreProcess(txt, src, tgt)
if 'siddhammukta' in postoptions and tgt == 'Siddham':
tgt = 'SiddhamDevanagari'
if 'siddhamap' in postoptions and tgt == 'Siddham':
tgt = 'SiddhamDevanagari'
if 'siddhammukta' in preoptions and src == 'Siddham':
src = 'SiddhamDevanagari'
if 'LaoNative' in postoptions and tgt == 'Lao':
tgt = 'Lao2'
if 'egrantamil' in preoptions and src == 'Grantha':
src = 'GranthaGrantamil'
if 'egrantamil' in postoptions and tgt == 'Grantha':
tgt = 'GranthaGrantamil'
if 'nepaldevafont' in postoptions and tgt == 'Newa':
tgt = 'Devanagari'
if 'ranjanalantsa' in postoptions and tgt == 'Ranjana':
tgt = 'Tibetan'
nativize = False
if 'ranjanawartu' in postoptions and tgt == 'Ranjana':
tgt = 'Tibetan'
nativize = False
for options in preoptions:
txt = getattr(PreProcess, options)(txt)
transliteration = Convert.convertScript(txt, src, tgt)
if nativize:
transliteration = PostOptions.ApplyScriptDefaults(
transliteration, src, tgt)
if tgt != 'Tamil':
transliteration = PostProcess.RemoveDiacritics(transliteration)
else:
transliteration = PostProcess.RemoveDiacriticsTamil(
transliteration)
for options in postoptions:
transliteration = getattr(PostProcess, options)(transliteration)
if src == "Tamil" and tgt == "IPA":
r = requests.get("http://anunaadam.appspot.com/api?text=" + txt +
"&method=2")
r.encoding = r.apparent_encoding
transliteration = r.text
return transliteration
def __init__(self, svcname='status', host=None,
suppress_fetch_errors=False,
suppress_conversion_errors=False):
super(g2StatusObj, self).__init__()
self.svcname = svcname
# holds all kinds of data about SOSS status aliases
self.info = Convert.statusInfo()
if host:
ro.init([host])
else:
ro.init()
self.reset()
def evaluation_final(config):
print("Evaluating Final Result")
images = tifffile.imread(config.deployLabels)
target = config.getResultFile("final_target.tif")
tifffile.imsave(target, images[config.segmentRange])
arr = Convert.loadMHA(glob.glob(config.getResultFile("final_*.mha")))
arr[arr != 0.0] = 255
arr = arr.astype(np.uint8)
final = config.getResultFile("final.tif")
tifffile.imsave(final, arr)
p = subprocess.Popen(["java", "-jar", "Evaluation.jar", target, final],
stdout=config.logStream,
stderr=config.logStream)
p.wait()
config.logStream.flush()
def on_click_Convert_OpenFile(self):
fni = self.ui.myTextInput_Convert_fileIn.text()
fno = self.ui.myTextInput_Convert_fileOut.text()
#pos = self.ui.checkBox_POS.isChecked()
print("Input file to be processed: {}".format(fni))
print("Output file: {}".format(fno))
#print("Conversion direction = {}".format(pos))
self.ui.textBrowser.append(
"Begin conversion (using OpenCC) on " +
f"{datetime.datetime.now():%Y-%m-%d at %H:%M:%S}")
self.ui.textBrowser.repaint()
# determine conversion direction from UI
conversion_direction = 's2tw' # default (see OpenCC docs)
if self.ui.radioButton_zht2zhs.isChecked():
conversion_direction = 't2s'
elif self.ui.radioButton_zhs2zht.isChecked():
conversion_direction = 's2tw'
elif self.ui.radioButton_enLowercse.isChecked():
conversion_direction = 'enlc'
if os.path.exists(fni) and fno != '':
#ret = processSegment(fni, fno, LANG, pos, lib, self)
if conversion_direction in ['s2tw', 't2s']:
start_time = time.time()
import Convert
doc = Convert.ZhtZhsConvert(fni, fno, conversion_direction,
self)
#line_count = Convert.lineCount(fni)
ret = doc.convert()
elapsed_time = round(time.time() - start_time, 2)
self.ui.textBrowser.append(
"Conversion complete in {} seconds".format(elapsed_time))
self.ui.textBrowser.repaint()
elif conversion_direction in ['enlc']:
pass
else:
self.ui.textBrowser.append(
"Input or output file is empty. Nothing to do!")
self.ui.textBrowser.repaint()
def projection_to_solution_space_by_L1(D, X, S, Y, U, parameter_rho_coef,
parameter_gamma, iteration, thr, cri,
dsz):
Df = con.convert_to_Df(D, S, cri)
Xf = con.convert_to_Xf(X, S, cri)
for i in range(iteration):
YSUf = con.convert_to_Sf(Y + S - U, cri)
b = (1 / parameter_rho_coef) * Xf + np.conj(Df) * YSUf
Xf = sl.solvedbi_sm(Df, (1 / parameter_rho_coef), b)
X = con.convert_to_X(Xf, cri)
#X = np.where(X <= 0, 0, X)
Xf = con.convert_to_Xf(X, S, cri)
DfXf = np.sum(Df * Xf, axis=cri.axisM)
DX = con.convert_to_S(DfXf, cri)
Y = sp.prox_l1(DX - S + U, (parameter_gamma / parameter_rho_coef))
U = U + DX - Y - S
return X, Y, U
def dictionary_learning_by_L2(X, S, dsz, G, H, parameter_rho_dic, iteration,
thr, cri):
Xf = con.convert_to_Xf(X, S, cri)
bar_D = tqdm(total=iteration, desc='D', leave=False)
for i in range(iteration):
Gf = con.convert_to_Df(G, S, cri)
Hf = con.convert_to_Df(H, S, cri)
GH = Gf - Hf
Sf = con.convert_to_Sf(S, cri)
b = parameter_rho_dic * GH + sl.inner(np.conj(Xf), Sf, cri.axisK)
Df = sl.solvemdbi_ism(Xf, parameter_rho_dic, b, cri.axisM, cri.axisK)
D = con.convert_to_D(Df, dsz, cri)
XfDf = np.sum(Xf * Df, axis=cri.axisM)
XD = con.convert_to_S(XfDf, cri)
Dr = np.asarray(D.reshape(cri.shpD), dtype=S.dtype)
Hr = np.asarray(H.reshape(cri.shpD), dtype=S.dtype)
Pcn = cr.getPcn(dsz, cri.Nv, cri.dimN, cri.dimCd)
Gr = Pcn(Dr + Hr)
G = cr.bcrop(Gr, dsz, cri.dimN).squeeze()
H = H + D - G
Est = sp.norm_2l2(XD - S)
if (i == 0):
pre_Est = 1.1 * Est
if ((pre_Est - Est) / pre_Est <= thr):
bar_D.update(iteration - i)
break
pre_Est = Est
bar_D.update(1)
bar_D.close()
return D, G, H
