def open_visualisation(self, event):
import Visualization
# dlg = tk.Toplevel(self.master)
r = tk.Tk()
dialog = Visualization.Visualization(r)
dialog.fill_combobox1()
dialog.run()
def __import_fuel_map(self):
user_settings = UserSettings()
file_filter = 'Ascii file (*' + AsciiParser.FILE_EXT + ')'
file, filt = QFileDialog.getOpenFileName(self, 'Open File', user_settings.working_dir, file_filter)
if file:
# FIXME: increase SIZE when there are lots of cells in fuel map and ignition
qApp.setOverrideCursor(Qt.WaitCursor)
try:
new_editor = FuelMapViewer(self, file)
except IndexError:
qApp.restoreOverrideCursor()
QMessageBox.information(self, "Invalid file", "A problem occurred while loading the fuel map. Please "
"verify that the fuel map does not contain non-integer "
"numbers")
return
if self._fl_map_editor:
self._fl_map_editor.deleteLater()
self._fl_map_editor = new_editor
self._fl_map_editor.setEnabled(True)
self.__setup_fl_map_lgnd()
# Enable relevant widgets
self.action_export_fuel_map.setEnabled(True)
# This means that a DEM has already been loaded,
# so the user can now convert to FDS file
if self._ign_pt_editor:
self.__init_sim_settings()
self.action_create_environment.setEnabled(True)
if self._visualization:
self._visualization.deleteLater()
self._visualization = Visualization(self._fl_map_editor.parser(), self._ign_pt_editor.parser(), self)
self._visualization.setEnabled(True)
self._visualization.hide()
# Set current tab to fuel type legend
self._tab_widget.setCurrentIndex(1)
self._fm_title_label.setText("Fuel Map Title: " + util.get_filename(file))
# Tab index might not change, so __tab_changed will never get called
self._fl_map_editor.show()
qApp.restoreOverrideCursor()
def __import_dem(self):
user_settings = UserSettings()
file_filter = 'Ascii file (*' + AsciiParser.FILE_EXT + ')'
file, filt = QFileDialog.getOpenFileName(self, 'Open File',
user_settings.working_dir,
file_filter)
if file:
qApp.setOverrideCursor(Qt.WaitCursor)
if self._ign_pt_editor:
self._ign_pt_editor.deleteLater()
self._ign_pt_editor = IgnitionPointViewer(self, file)
self._ign_pt_editor.setEnabled(True)
self._setup_ign_pt_map_lgnd()
# Enable relevant widgets
self.action_export_dem.setEnabled(True)
# This means that a fuel map has already been loaded,
# so the user can now convert to FDS file
if self._fl_map_editor:
self.__init_sim_settings()
self.action_create_environment.setEnabled(True)
if self._visualization:
self._visualization.deleteLater()
self._visualization = Visualization(
self._fl_map_editor.parser(), self._ign_pt_editor.parser(),
self)
self._visualization.setEnabled(True)
self._visualization.hide()
# Set current tab to fuel type legend
self._tab_widget.setCurrentIndex(2)
self._dem_title_label.setText("DEM Title: " +
util.get_filename(file))
self._ign_pt_editor.show()
qApp.restoreOverrideCursor()
def auto(tiss, data="Female"):
print('\n')
segmentation, dico = getDSubstance(data, tiss)
dicomdir = segmentation.dicomdir
print('Dicom Dir : ', dicomdir)
print('Initialize ImageDicom')
image = segmentation.dicomimage
if "box" in dico.keys():
image.cropBoxImages(dico["box"]["dheight"], dico["box"]["drow"],
dico["box"]["dcolumn"])
segmentation.data_dico[segmentation.name]["box"] = dico["box"]
print("height :", image.height)
segmentation.pipeline()
print('Initialize Visualization')
myMesh = Visualization(segmentation)
myMesh.pipeline()
print('Object Created')
print('----------')
print('\n')
from Visualization import *
from defined_maps import *
tile_len = 50
speed = 10
ticks = 10
map, tasks, cars, spawn_points, cars_points, solver = get_scenario1(tile_len, speed)
vis = Visualization(map.to_bitman_objects(), tile_len, cars=cars, ticks=ticks, spawn_points=spawn_points,
cars_points=cars_points,
solver=solver)
vis.run()
C.add_road('Lyon', 'Nantes')
C.add_road('Lyon', 'Aix')
C.add_road('Aix', 'Amiens')
C.add_road('Aix', 'Nantes')
C.add_road('Aix', 'Lyon')
C.add_road('Amiens', 'Aix')
C.add_road('Amiens', 'Lille')
C.add_road('Amiens', 'Nantes')
C.add_road('Lille', 'Amiens')
C.add_road('Lille', 'Paris')
C.add_road('Tour', 'Nantes')
C.add_road('Nantes', 'Paris')
C.add_road('Nantes', 'Tour')
C.add_road('Nantes', 'Lyon')
C.add_road('Nantes', 'Aix')
C.add_road('Nantes', 'Amiens')
C.add_road('Paris', 'Lille')
C.add_road('Paris', 'Nantes')
C.initialize()
#print(C)
window = Visualization(C)
window.mainloop()
def run_visualization(currModel, show_simulation_dynamics = False):
print "Setting up visualization..."
morphology = currModel.get_reconstruction()
# Prepare model coordinates for uploading to OpenGL.
tempIndices = []
tempVertices = []
n_index = 0
tempX = []
tempY = []
tempZ = []
tempCol = []
if not show_simulation_dynamics:
print '''
Soma - Red
Axon - Green
Dendrites - Blue
Apical Dendrites - Purple'''
# array of colors to denote individual compartment types
compartmentColors=[[0.0,0.0,0.0,0.0], # padding for index convenience
[1.0, 0.0, 0.0, 1.0], #1: soma - red
[0.0, 1.0, 0.0, 1.0], #2: axon - green
[0.0, 0.0, 1.0, 1.0], #3: dendrites - blue
[1.0, 0.0, 1.0, 1.0]] #4: apical dendrites - purple
color_dim = 4
# used to set up section monitoring for visualization of dynamics
compartmentNames=['none', # padding for index convenience
'soma', #1: soma
'axon', #2: axon
'dend', #3: dendrites - blue
'dend'] #4: apical dendrites - purple
sectionIndices=[0,0,0,0,0]
segmentsPerSection = {}
sec_name = ''
# initialize storage arrays for each vertex.
index = 0
n_compartments = len(morphology.compartment_list)
tempX = [0] * n_compartments
tempY = [0] * n_compartments
tempZ = [0] * n_compartments
tempCol = [0] * n_compartments * color_dim
for n in morphology.compartment_list:
# add parent coords
tempX[n['id']] = n['x']
tempY[n['id']] = -n['y']
tempZ[n['id']] = n['z']
# add color data for parent
col_i = 0
offset = n['id']*color_dim
for cval in compartmentColors[n['type']]:
tempCol[offset+col_i] = cval
col_i += 1
# if at a branch point or an end of a section, set up a vector to monitor that segment's voltage
type = compartmentNames[n['type']]
sec_index = sectionIndices[n['type']]
if not (len(morphology.children_of(n)) == 1): #either branch pt or end
sec_name = type + '[' + str(sec_index) + ']'
sectionIndices[n['type']] += 1
currModel.monitor_section_voltage(type, sec_index)
segmentsPerSection[sec_name] = 1
else:
segmentsPerSection[sec_name] += 1
index += 1
for c in morphology.children_of(n):
# add child coods
tempX[c['id']] = c['x']
tempY[c['id']] = -c['y']
tempZ[c['id']] = c['z']
# add index data:
# draw from parent to child, for each child
tempIndices.append(n['id'])
tempIndices.append(c['id'])
index += 1
# add color data for child
col_i = 0
offset = c['id']*color_dim
for cval in compartmentColors[c['type']]:
tempCol[offset+col_i] = cval
col_i += 1
segmentsPerSection[sec_name] += 1
# get ranges for scaling
maxX = max(tempX)
maxY = max(tempY)
maxZ = max(tempZ)
minX = min(tempX)
minY = min(tempY)
minZ = min(tempZ)
xHalfRange = (maxX - minX)/2.0
yHalfRange = (maxY - minY)/2.0
zHalfRange = (maxZ - minZ)/2.0
longestDimLen = max(xHalfRange, yHalfRange, zHalfRange)
# center coords about 0,0,0, with range -1 to 1
tempX = [((((x-minX)*(2*xHalfRange))/(2*xHalfRange)) - xHalfRange)/longestDimLen for x in tempX]
tempY = [((((y-minY)*(2*yHalfRange))/(2*yHalfRange)) - yHalfRange)/longestDimLen for y in tempY]
tempZ = [((((z-minZ)*(2*zHalfRange))/(2*zHalfRange)) - zHalfRange)/longestDimLen for z in tempZ]
# convert everything to a numpy array so OpenGL can use it
indexData = np.array(tempIndices, dtype='uint16')
vertexData = np.array([tempX,tempY,tempZ], dtype='float32')
tempCol = np.array(tempCol, dtype='float32')
vertexData = np.append(vertexData.transpose().flatten(), tempCol)
#################### /Preparing Model Coords
# Set up the Visualization instance
n_vertices = len(tempX)
currVis = Visualization(data=vertexData, indices=indexData, nVert=n_vertices, colorDim=color_dim)
if show_simulation_dynamics:
currModel.run_test_pulse(amp=0.25, delay=20.0, dur=20.0, tstop=60.0)
#currModel.plot_output() # uncomment this line to display the somatic potential over time before the visualization begins
sectionOutput = currModel.section_output
n_segments = n_vertices
# set up looping color change data
all_voltages = []
n_pts = len(sectionOutput['t'])
for t in range(n_pts): # for each timepoint...
for key in sectionOutput.keys(): # for each section...
if key != 't':
for s in range(segmentsPerSection[key]): # for each segment...
all_voltages.append(sectionOutput[key][t]) # ...set up color for segment
all_voltages = np.array(all_voltages, dtype='float32')
all_voltages -= min(all_voltages)
all_voltages /= max(all_voltages)
temp_col = []
n_pts = 0
for v in all_voltages:
temp_col.append(v)
temp_col.append(0.0)
temp_col.append(1.0-v)
temp_col.append(1.0)
n_pts += 1
voltage_col = np.array(temp_col, dtype='float32')
currVis.change_color_loop(voltage_col, n_colors=n_segments, n_timepoints=n_pts, offset=0, rate=0.10)
currVis.run()
def astar():
h, w = 10, 10
threshold = 0.5
start_point = [5, 3, 0]
goal_state = [9, 9]
w1, w2 = 5, 10
nodes = queue.PriorityQueue()
init_node = Node(start_point, None, None, 0, None)
nodes.put((init_node.getCost(), init_node))
traversed_nodes = []
obs = Obstacle(0.0)
viz = Visualization(obs)
fig, ax = plt.subplots(figsize=(10, 10))
ax.set(xlim=(0, 10), ylim=(0, 10))
ax = viz.addObstacles2Map(ax)
ax.set_aspect("equal")
goal_reached = False
node_array = np.array([[[math.inf for k in range(360)]
for j in range(int(h / threshold))]
for i in range(int(w / threshold))])
full_path = None
goal_reached = False
print('Finding path.........')
while (not nodes.empty()):
current_node = nodes.get()[1]
traversed_nodes.append(current_node)
if checkGoalReached(current_node, goal_state, 1):
print('Goal reached')
print("The cost of path: ", current_node.getCost())
moves, node_path = current_node.getFullPath()
visualize(viz, traversed_nodes, node_path)
goal_reached = True
fp = open('path_points.csv', 'w')
fn = open('path_nodes.csv', 'w')
fv = open('vel_points.csv', 'w')
writer_p = csv.writer(fp)
writer_n = csv.writer(fn)
writer_v = csv.writer(fv)
for move in moves:
writer_v.writerow(move)
for node in node_path:
xi, yi, _ = node.getState()
writer_n.writerow([xi, yi])
points = node.getPathArray()
if points is not None:
for point in points:
xn, yn = point
row = [xn, yn]
writer_p.writerow(row)
xi, yi = xn, yn
fp.close()
fv.close()
fn.close()
else:
branches = getBranches(current_node, 1, w1, w2, obs)
for branch_node in branches:
branch_state = branch_node.getState()
if checkVisited(branch_node,
node_array,
goal_state,
threshold=0.5):
node_array[int(halfRound(branch_state[0]) / threshold),
int(halfRound(branch_state[1]) / threshold),
branch_state[2]] = branch_node.getCost(
) + computeHeuristicCost(
branch_state, goal_state)
nodes.put((branch_node.getCost() +
computeHeuristicCost(branch_state, goal_state),
branch_node))
if (goal_reached): break
#!/usr/bin/env python3
# Final Project - Lichtenberg Figures
import numpy as np
import Configuration
import Visualization
import Pipeline
# Load configuration file.
configuration_info = Configuration.Configuration()
# Create spacing, needed for correct grid scale automatically.
x_points = np.linspace(0, 1, num=configuration_info.grid_resolution_x_points)
y_points = np.linspace(0, 1, num=configuration_info.grid_resolution_y_points)
# Calculate corresponding offset (needed so pixels are not truncated)
x_offset = x_points[1] / 2.0
y_offset = y_points[1] / 2.0
# Create a meshgrid.
xs, ys = np.meshgrid(x_points, y_points)
# Create a pipeline for performing steps and create initial points.
pipeline_process = Pipeline.Pipeline(configuration_info)
# Create animation.
visualizer = Visualization.Visualization(x_offset, y_offset,
configuration_info, pipeline_process)
visualizer.create_animation()
def populateArgWithCellIndexHandler(self, argIdx=0):
def cellIndexHandler(event):
can = self.app.canvas
if event.widget is can:
for item in can.find_closest(can.canvasx(event.x),
can.canvasy(event.y)):
if item in self.indices:
self.app.setArgument(
self.app.canvas_itemConfig(item, 'text'), argIdx)
return cellIndexHandler
if __name__ == '__main__':
from drawnValue import *
app = Visualization(title='Table test', canvasBounds=(0, 0, 800, 400))
app.setArgument = lambda arg, argIndex: print('Set argument', argIndex,
'to {!r}'.format(arg))
app.startAnimations()
table1 = Table(
app, (100, 50),
'foo',
'bar',
label='Foo bar',
vertical=True,
indicesFont=('Courier', -14),
see=True,
cellHeight=30,
cellBorderWidth=4,
if __name__ == '__main__':
from drawnValue import *
import random, sys, argparse
parser = argparse.ArgumentParser(
description='Test ' + __file__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('label', nargs='*', help='Label(s) to draw.')
parser.add_argument('-s',
'--sleep-time',
default=0.01,
type=float,
help='Sleep time for animation.')
args = parser.parse_args()
app = Visualization(title='OutputBox test', canvasBounds=(0, 0, 800, 400))
app.startAnimations()
width, height = 140, 25
outbox1 = OutputBox(
app, (400 - width // 2 - 5, 190, 400 + width // 2 + 5, 190 + height),
label='Output Item')
print('Output box 1: {}', outbox1)
app.wait(1)
toAdd = 'Item'
print('Append {!r} to output box 1'.format(toAdd))
outbox1.appendText(toAdd)
app.wait(1)
dataItems = []
dy = height // 4
from Visualization import *
if __name__ == '__main__':
app = Visualization(title='Font Scaling')
for size in range(20, 0, -1):
for x, face in enumerate(('Helvetica', 'Courier')):
font = (face, -size)
ds = 4
y0 = (size + ds) * (size + ds) // 2
x0 = 50 + x * 300
app.canvas.create_text(
x0,
y0,
text=str(font),
anchor=NW,
font=font,
fill=app.VALUE_COLOR if x == 0 else app.VARIABLE_COLOR)
dx = 5
app.canvas.create_rectangle(x0 - size - dx,
y0,
x0 - dx,
y0 + size,
fill='blue' if x == 0 else 'red',
width=0)
app.runVisualization()
import numpy as np import matplotlib.pyplot as plt import math import pandas as pd import Visualization as vis VIS = vis.Visualization() VIS.call_simulation()
def resetGame(back, front):
back.resetBoard()
front.board.replace_board(np.rot90(np.array(back.grid), 3))
front.board.current_player = random.randint(1, 2)
#Plays move for front and backend
def playMove(player, col):
backEnd.submitMove(col, player)
if __name__ == "__main__":
width = 7
height = 6
backEnd = Game(width, height)
frontEnd = Visualization(500, 500)
frontEnd.board = Board(width, height)
frontEnd.board.current_player = random.randint(1, 2)
# Computer == turn 1
while True:
#Press Left Arrow Key to exit game
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
exit()
if frontEnd.board.current_player == 1:
#Computer makes a move
time.sleep(.7)
column_to_place = random.choice(backEnd.getLegalMoves())
