def checkandOperate(self):
#split the userInput with ' " ', and 2 is the largest index of the return list
inputInfoSplit = self.str.split("\"", 2)
# #print("cmd:", inputInfoSplit[0])
#inputInfoSplit contains [cmd, streetname, streetpoints] which is not verified yet
if len(inputInfoSplit) == 1:
#g
stdGraph = re.compile(r'[g][ ]*')
graphMatchResult = re.match(stdGraph, inputInfoSplit[0])
if not graphMatchResult:
raise Exception("Error: Wrong command.")
else:
#graph
graph.build_graph()
# print("graph")
elif len(inputInfoSplit) == 0:
raise Exception("Error: Not enough arguments.")
elif len(inputInfoSplit) == 3 or len(inputInfoSplit) == 2:
#verify Command using regular expression
#(permitting cmd entered with blank(s))
stdCmds = re.compile(r'[acr][ ]*')
cmdMatchResult = re.match(stdCmds, inputInfoSplit[0])
if not cmdMatchResult:
raise Exception("Error: Wrong command.")
else:
self.cmd = inputInfoSplit[0]
#verify Streetname
stdStreetName = re.compile(r'^([a-zA-Z ])+$')
nameMatchResult = re.match(stdStreetName, inputInfoSplit[1])
if not nameMatchResult:
raise Exception(
"Error: Wrong name format.(accept letters and blanks)")
else:
self.street.name = inputInfoSplit[1]
#add
stdAdd = re.compile(r'[a][ ]*')
addMatchResult = re.match(stdAdd, self.cmd)
#change
stdChang = re.compile(r'[c][ ]*')
changMatchResult = re.match(stdChang, self.cmd)
#remove
stdRemove = re.compile(r'[r][ ]*')
removeMatchResult = re.match(stdRemove, self.cmd)
if addMatchResult:
self.checkandAdd(inputInfoSplit)
elif changMatchResult:
self.checkandChange(inputInfoSplit)
elif removeMatchResult:
self.checkandRemove(inputInfoSplit)
else:
pass
else:
raise Exception("Error: Wrong command and arguments.")
def graphs():
x1 = [0, 1, 2, 3, 4]
y1 = [10, 30, 40, 5, 50]
x2 = [0, 1, 2, 3, 4]
y2 = [50, 30, 20, 10, 50]
graph1_url = build_graph(x1, y1)
graph2_url = build_graph(x2, y2)
return render_template('graphs.html', graph1=graph1_url, graph2=graph2_url)
def graph ():
x1 = [0, 1, 2, 3, 4]
y1 = [10, 30, 40, 5, 50]
x2 = [0, 1, 2, 3, 4]
y2 = [50, 30, 20, 10, 50]
x3 = [0, 1, 2, 3, 4]
y3 = [0, 30, 10, 5, 30]
graph1_url = build_graph(x1,y1);
graph2_url = build_graph(x2,y2);
graph3_url = build_graph(x3,y3);
return render_template('graph.html', graph1=graph1_url, graph2=graph2_url, graph3=graph3_url)
def build_map(array):
'''
Builds map with countries in colours.
'''
print('')
with open('locations.json', 'r', encoding='utf-8') as f:
dicti = json.load(f)
user_map = folium.Map(max_zoom=7, min_zoom=2)
country_names = []
dicti_coor = {}
for q in array:
years = []
users = []
cur = q._qhead
while cur is not None:
years.append(cur.year)
users.append(cur.item)
cur = cur.next
dicti_coor[tuple(dicti[q._name])] = (tuple(users), tuple(years),
q._name)
country_names.append(q._name)
fg_psn = folium.FeatureGroup(name="Users")
fg_psn.add_child(
folium.GeoJson(
data=open('world.json', 'r', encoding='utf-8-sig').read(),
style_function=lambda x: {
'fillColor':
'red' if x['properties']['NAME'] in country_names else 'white',
'color':
'black',
'weight':
2.5
})).add_to(user_map)
for loc in dicti_coor:
location = loc
(users, years, country) = dicti_coor[loc]
build_graph(users, years, country)
encoded = base64.b64encode(
open('graphs/graph' + country + '.JPG', 'rb').read())
html = '<img src="data:image/jpeg;base64,{}">'.format
iframe = folium.IFrame(html(encoded.decode('UTF-8')),
width=420,
height=308)
popup = folium.Popup(iframe, max_width=2000)
folium.Marker(location=[float(location[0]),
float(location[1])],
popup=popup).add_to(user_map)
user_map.save('templates/users.html')
def run(session):
batcher = preprocessing.Batcher(config.SUBSAMPLE_THRESHOLD,
config.TEST_MODE)
num_batches = batcher.num_batches(config.BATCH_SIZE)
graph = graph_fns.build_graph(
vocab_size=batcher.vocab_size(),
num_embedding_units=config.NUM_EMBEDDING_UNITS,
num_negative_samples=config.NUM_NEGATIVE_SAMPLES,
)
session.run(tf.global_variables_initializer())
run_info = RunInfo(
session=session,
graph=graph,
saver=tf.train.Saver(),
batcher=batcher,
validator=validator.Validator(batcher.vocab_size(),
graph.embedding_matrix),
batch_size=config.BATCH_SIZE,
window_size=config.WINDOW_SIZE,
batches_per_epoch=num_batches,
batches_per_logging=int(num_batches * config.LOGGING_FREQUENCY),
batches_per_save=int(num_batches * config.SAVING_FREQUENCY),
batches_per_validation=int(num_batches * config.VALIDATION_FREQUENCY),
)
for epoch_idx in range(1, config.NUM_EPOCHS + 1):
run_epoch(run_info, epoch_idx)
def get_segmented_image(sigma, neighbor, K, min_comp_size, input_file,
output_file):
if neighbor != 4 and neighbor != 8:
logger.warn(
'Invalid neighborhood choosed. The acceptable values are 4 or 8.')
logger.warn('Segmenting with 4-neighborhood...')
start_time = time.time()
image_file = Image.open(input_file)
size = image_file.size # (width, height) in Pillow/PIL
logger.info('Параметры изображения: {} | {} | {}'.format(
image_file.format, size, image_file.mode))
# Gaussian Filter
smooth = image_file.filter(ImageFilter.GaussianBlur(sigma))
smooth = np.array(smooth).astype(int)
logger.info("Создание графа...")
graph_edges = build_graph(smooth, size[1], size[0], diff, neighbor == 8)
logger.info("Вычисление разреза...")
forest = segment_graph(graph_edges, size[0] * size[1], K, min_comp_size,
threshold)
logger.info("Визуализация: {}".format(output_file))
image = generate_image(forest, size[1], size[0])
image.save(output_file)
logger.info('Количество сегментов: {}'.format(forest.num_sets))
logger.info('Общее время выполнения: {:0.4}s'.format(time.time() -
start_time))
def main(sigma, neighborhood, K ,min_size ,input_file):
neighbor = neighborhood
if neighbor != 4 and neighbor!= 8:
print('Invalid neighborhood choosed. The acceptable values are 4 or 8.')
print('Segmenting with 4-neighborhood...')
image_file = Image.open(input_file)
image_file = image_file.resize((250,250))
size = image_file.size
#print ('Image info: ', image_file.format, size, image_file.mode)
grid = gaussian_grid(sigma)
#2print(image_file.mode)
if image_file.mode == 'RGB':
image_file.load()
r, g, b = image_file.split()
r = filter_image(r, grid)
g = filter_image(g, grid)
b = filter_image(b, grid)
smooth = (r, g, b)
diff = diff_rgb
else:
return 0
graph = build_graph(smooth, size[1], size[0], diff, neighbor == 8)
forest = segment_graph(graph, size[0]*size[1], K, min_size, threshold)
image = generate_image(image_file , forest, size[1], size[0])
return image
print ('Number of components: %d' % forest.num_sets)
def get_segmented_image(sigma, neighbor, K, min_comp_size, input_file, output_file):
if neighbor != 4 and neighbor!= 8:
logger.warn('Invalid neighborhood choosed. The acceptable values are 4 or 8.')
logger.warn('Segmenting with 4-neighborhood...')
start_time = time.time()
image_file = Image.open(input_file)
size = image_file.size # (width, height) in Pillow/PIL
logger.info('Image info: {} | {} | {}'.format(image_file.format, size, image_file.mode))
# Gaussian Filter
smooth = image_file.filter(ImageFilter.GaussianBlur(sigma))
smooth = np.array(smooth)
logger.info("Creating graph...")
graph_edges = build_graph(smooth, size[1], size[0], diff, neighbor==8)
logger.info("Merging graph...")
forest = segment_graph(graph_edges, size[0]*size[1], K, min_comp_size, threshold)
logger.info("Visualizing segmentation and saving into: {}".format(output_file))
image = generate_image(forest, size[1], size[0])
image.save(output_file)
logger.info('Number of components: {}'.format(forest.num_sets))
logger.info('Total running time: {:0.4}s'.format(time.time() - start_time))
def get_segmented_image(sigma, neighbor, K, min_comp_size, input_file,
output_file):
if neighbor != 4 and neighbor != 8:
logger.warn(
'Invalid neighborhood choosed. The acceptable values are 4 or 8.')
logger.warn('Segmenting with 4-neighborhood...')
start_time = time.time()
image_file = Image.open(input_file)
size = image_file.size # (width, height) in Pillow/PIL
logger.info('Image info: {} | {} | {}'.format(image_file.format, size,
image_file.mode))
# Gaussian Filter
smooth = image_file.filter(ImageFilter.GaussianBlur(sigma))
smooth = np.array(smooth)
logger.info("Creating graph...")
graph_edges = build_graph(smooth, size[1], size[0], diff,
neighbor == 8) #返回8邻域中任意两个节点间的连接权值
logger.info("Merging graph...")
forest = segment_graph(graph_edges, size[0] * size[1], K, min_comp_size,
threshold)
logger.info(
"Visualizing segmentation and saving into: {}".format(output_file))
image = generate_image(forest, size[1], size[0])
image.save(output_file)
logger.info('Number of components: {}'.format(forest.num_sets))
logger.info('Total running time: {:0.4}s'.format(time.time() - start_time))
def run():
train_batches, validation_batches = batcher.partition_batches(
batcher.make_batches(config.file_reader.one_hot_text(),
config.BATCH_SIZE, config.STEP_SIZE))
num_training_batches = len(train_batches)
num_validation_batches = len(validation_batches)
batches_per_save = int(config.SAVE_FREQUENCY * num_training_batches)
batches_per_validation = int(config.VALIDATION_FREQUENCY *
num_training_batches)
graph = graph_fns.build_graph(config.BATCH_SIZE,
config.file_reader.vocab_size(),
config.NUM_LAYERS, config.STEP_SIZE,
config.NUM_LSTM_UNITS)
saver = tf.train.Saver()
run_info = RunInfo(train_batches=train_batches,
validation_batches=validation_batches,
num_training_batches=num_training_batches,
num_validation_batches=num_validation_batches,
batches_per_save=batches_per_save,
batches_per_validation=batches_per_validation,
graph=graph,
saver=saver)
with tf.Session() as session:
session.run(tf.global_variables_initializer())
for epoch_idx in range(config.NUM_EPOCHS):
run_epoch(session, run_info, epoch_idx)
def graph_based_segmentation(neighbor_list, num_nodes, K, min_size, threshold):
xcoor = []
ycoor = []
diff = []
length = 0
for i in range(len(neighbor_list)):
xcoor.append(neighbor_list[i][0])
ycoor.append(neighbor_list[i][1])
diff.append(neighbor_list[i][2])
graph = build_graph(length, diff, xcoor, ycoor)
forest = segment_graph(graph, num_nodes + 1, K, min_size, threshold)
# output prediction results
prediction = []
for x in xrange(num_nodes + 1):
prediction.append(forest.find(x))
# prediction clusters rename
name_set = []
for name in prediction:
if name not in name_set:
name_set.append(name)
rename = {}
for i in range(len(name_set)):
rename[name_set[i]] = i + 1
for i in range(len(prediction)):
prediction[i] = rename[prediction[i]]
# Write results to files and save
# with open('prediction','w') as f:
# for i in prediction:
# f.write(str(i) + '\n')
return [forest, prediction]
def seg_a_img(img, img_name, img_mode="remote_sensing"):
grid = gaussian_grid(SIGMA)
if img_mode == "remote_sensing":
c, h, w = img.shape[0], img.shape[1], img.shape[2]
print("we are working in geo-tif mode, img is read by gdal")
img_bands = []
for i in range(c):
img_bands.append(filter_image(img[i], grid))
smooth = tuple(img_bands)
diff = diff_geoTif
elif img_mode == "BGR":
print("we are working in BGR mode, the img is read by opencv")
h, w, c = img.shape[0], img.shape[1], img.shape[2]
smooth = []
for i in range(3):
smooth.append(filter_image(img[:, :, i], grid))
smooth = tuple(smooth)
diff = diff_rgb
else:
h, w = img.shape[0], img.shape[1]
smooth = filter_image(img, grid)
diff = diff_grey
graph = build_graph(smooth, w, h, diff, neighbor == 8)
forest = segment_graph(graph, h * w, K, MIN_SIZE, threshold)
image = generate_image(forest, w, h)
image.save("seg_res/%s.png" % img_name)
# image.save(sys.argv[6])
print 'Number of components: %d' % forest.num_sets
def graphs():
#These coordinates could be stored in DB
x1 = [0, 1, 2, 3, 4]
y1 = [10, 30, 40, 5, 50]
graph1_url = build_graph(x1, y1)
return render_template('graphs.html', graph1=graph1_url)
def view_graph(self):
'''
Open window with graph of progress
'''
if graphok == 0: # This means graph was imported correctly
selection = self.lbox.curselection()
note_select = self.libox.curselection()
if selection:
self.lpointer = int(selection[0])
graph.build_graph(self.goal_list.goals[self.lpointer])
else:
if note_select: # if cursor is on a note then a goal must have already been selected and lpointer already set.
graph.build_graph(self.goal_list.goals[self.lpointer])
else:
messagebox.showwarning("Warning", "No goal selected")
else: # if graph was not imported
messagebox.showwarning("Warning", "Matplotlib is not installed please refer to the user installation document.")
def graphs():
#These coordinates could be stored in DB
x1 = [0, 1, 2, 3, 4]
y1 = [10, 30, 40, 5, 50]
x2 = [0, 1, 2, 3, 4]
y2 = [50, 30, 20, 10, 50]
x3 = [0, 1, 2, 3, 4]
y3 = [0, 30, 10, 5, 30]
graph1_url = build_graph(x1,y1);
graph2_url = build_graph(x2,y2);
graph3_url = build_graph(x3,y3);
return render_template('graphs.html',
graph1=graph1_url,
graph2=graph2_url,
graph3=graph3_url)
def run_segmentation(self):
self.graph = build_graph(img=self.image_smooth,
width=self.width,
height=self.height,
diff=self.diff,
neighborhood_8=self.neighbor == 8)
self.forest = segment_graph(self.graph, self.height * self.width,
self.K, self.min_size, threshold)
def test():
graph_text = '''source1,dest1,dest2
source2,dest1,abc,dest2,abc'''
graph = build_graph(graph_text)
print_graph(graph)
print lookup ('source')
print lookup ('source1')
print lookup ('source2')
def start_search(state):
graph = g.build_graph() # Create an instance of the graph class
dt_travel = dt.Stack()
if state.breadth_search: # If Breadth First Search was Specified
breadth_first_search(
state, graph, state.starting_url) # Initiate Breadth First Search
if state.depth_search: # If Depth First Search was Specified
depth_first_search(state, graph, dt_travel,
state.starting_url) # Initiate Depth First Search
def run():
dataset = TextDataSet(f'../datasets/{config.DATASET_FILENAME}')
g = graph.build_graph(BATCH_SIZE, dataset.num_chars, config.NUM_LAYERS,
STEP_SIZE, config.NUM_LSTM_UNITS)
with tf.Session() as session:
session.run(tf.global_variables_initializer())
load_model(session)
states = graph.make_initial_sampling_states(config.NUM_LAYERS,
config.NUM_LSTM_UNITS)
return create_sample(session, g, dataset, states)
def eulerian(filename):
""" Return wheter or not the graph built from the given file contains a eulerian cycle """
# read from a file to grab graph properties
graph, vertices, edges = read_file(filename)
# builded graph object
graph = build_graph(graph, vertices, edges)
eulerian = graph.is_eulerian()
print("This graph is Eulerian: {}".format(eulerian))
def graphs():
#These coordinates could be stored in DB
x1 = [0, 1, 2, 3, 4]
y1 = [10, 30, 40, 5, 50]
x2 = [0, 1, 2, 3, 4]
y2 = [50, 30, 20, 10, 50]
x3 = [0, 1, 2, 3, 4]
y3 = [0, 30, 10, 5, 30]
plt.plot([0, 0.1, 0.2, 0.3])
plt.ylabel('Stenosis Trend')
axis([0,750,25,100])
plt.show()
graph0_url = build_graph([x1,y1],[x2,y2]);
graph1_url = build_graph(x1,y1);
graph2_url = build_graph(x2,y2);
graph3_url = build_graph(x3,y3);
return render_template('graphs.html', graph12=graph12_url, graph1=graph1_url, graph2=graph2_url, graph3=graph3_url)
def graph1():
checkSession()
source_biases = weightranking.source_user_biases(session["srcdict"])
x1 = []
y1 = []
for x in source_biases:
x1.append(x[0])
y1.append(x[1])
graph1_url = graph.build_graph(x1, y1)
if request.method == "GET":
return render_template('graph.html', graph1=graph1_url)
def graphs():
#Clears all previously plotted graphs
plt.close('all')
#Regenerate random numbers
xpts, ypts, labels = generateTestData()
graph1_url = g.build_graph(g.build_x0(xpts, ypts, labels, colors))
g1, fpcs = g.build_x1(xpts, ypts, labels, colors, np)
graph2_url = g.build_graph(g1)
graph3_url = g.build_graph(g.build_x2(xpts, ypts, labels, colors, np,
fpcs))
graph4_url = g.build_graph(g.build_x3(xpts, ypts, labels, colors, np))
return render_template(
'graphs.html',
graph1=graph1_url,
graph2=graph2_url,
graph3=graph3_url,
graph4=graph4_url,
)
def graphs():
test_gender, test_class, df_test_processed = process_test_data()
df_bar = pd.DataFrame({
'Emotion':
lgbm_model_class.classes_,
'Percentage': [
np.round(x * 100, 1)
for x in lgbm_model_class.predict_proba(test_class)[0]
]
})
df_bar = df_bar.sort_values(by='Percentage', ascending=False)
graph1_url = build_graph(df_bar['Emotion'].values,
df_bar['Percentage'].values)
return render_template('graphs.html', graph1=graph1_url)
def index():
masters = Master.query.all()
slaves_list = []
if len(masters) is 0:
return render_template('device/master_enroll_check.html')
for master in masters:
slaves = Slave.query.filter_by(master_id=master.id).all()
if len(slaves) is 0:
return render_template('device/master_enroll_check.html')
for slave in slaves:
graph_url_list = []
text = ''
route = 'slaves/'
slave_RXAddr = slave.RXAddr
csv = '.txt'
route += slave_RXAddr
route += csv
f = open(route, "r")
texts = f.readlines()
f.close()
text_list = []
for text in texts:
text = text.replace('\n', '')
text_list.append(text.split('|'))
# x = KW, y = 시간
x = []
y = []
for text in text_list[1:]:
x.append(int(text[4]))
y.append(
int(text[1]) * 3600 + int(text[2]) * 60 + int(text[3]))
graph_url = build_graph(y, x)
graph_url_list.append(graph_url)
slave.graph_url = graph_url
slaves_list.append(slave)
return render_template('index.html', slaves=slaves_list)
def display_sensors():
sensor_list = User.get_sensors(current_user.id)
humidity_sensors = []
temperature_sensors = []
for sensor in sensor_list:
sensor_dict = dict(zip(sensor.keys(), sensor))
if sensor_dict["sensor_type"] == "Humidity":
humidity_sensors.append(sensor_dict["sensor_name"])
elif sensor_dict["sensor_type"] == "Temperature":
temperature_sensors.append(sensor_dict["sensor_name"])
plot_url = build_graph(humidity_sensors, temperature_sensors)
return render_template('display_sensors.html', graph=plot_url)
def vs_graph(term, radius, fpath, trim_leaves=False):
"""Build a neighborhood graph of the search term
\b
Args:
term: Word to search for
radius: Maximum distance away from the central node to keep in the graph
fpath: Where to save the html output.
"""
if not fpath:
fpath = get_valid_filename(term) + ".html"
g = build_graph(term, radius=radius, trim_leaves=trim_leaves)
build_plot(term, g, fpath)
def main(_):
ps_hosts = FLAGS.ps_hosts.split(",")
worker_hosts = FLAGS.worker_hosts.split(",")
# 使用参数服务器和工作节点创建集群
cluster = tf.train.ClusterSpec({"ps": ps_hosts, "worker": worker_hosts})
# 创建并启动服务
server = tf.train.Server(cluster,
job_name=FLAGS.job_name,
task_index=FLAGS.task_index)
if FLAGS.job_name == "ps":
server.join()
elif FLAGS.job_name == "worker":
with tf.device(
tf.train.replica_device_setter(
worker_device="/job:worker/task:%d" % FLAGS.task_index,
cluster=cluster)):
x, y_, train_step, accuracy = build_graph()
hooks = [
tf.train.StopAtStepHook(last_step=TRAINING_STEPS),
tf.train.CheckpointSaverHook(checkpoint_dir=MODEL_PATH,
save_secs=600,
saver=tf.train.Saver(sharded=True))
]
is_chief = (FLAGS.task_index == 0)
i = 1
validate_feed = {
x: mnist.validation.images,
y_: mnist.validation.labels
}
with tf.train.MonitoredTrainingSession(master=server.target,
is_chief=is_chief,
checkpoint_dir=MODEL_PATH,
hooks=hooks) as mon_sess:
while not mon_sess.should_stop():
xs, ys = mnist.train.next_batch(BATCH_SIZE)
mon_sess.run(train_step, feed_dict={x: xs, y_: ys})
i += 1
if i % 100 == 0:
validate_acc = mon_sess.run(accuracy,
feed_dict=validate_feed)
print("After %d training step(s), validation accuracy "
"using average model is %g" % (i, validate_acc))
async def play_learned_ai(callback):
import config
import graph as g
import main
import play
import tensorflow as tf
with tf.Session() as session:
graph = g.build_graph()
saver = tf.train.Saver()
saver.restore(session, config.CHECKPOINT_FILENAME)
await play.async_evaluate_performance(
session,
graph,
training_mode = False,
callback = callback
)
def compute_features(self, tsv_file):
graph = helper.build_graph(tsv_file)
self.graph = graph
self.undirected_graph = graph.to_undirected()
self.embeddedness_matrix = helper.get_embeddedbess_matrix(graph)
features_df = self.build_features_df(graph)
self.matrix = nx.to_numpy_matrix(graph, weight="weight")
# Parallel calculation of the features, each thread calculates a different chunk
features_df_split = np.array_split(features_df, NUMBER_OF_CORES)
pool = mp.Pool(NUMBER_OF_CORES)
parts = pool.map(self.process_frame, features_df_split)
df = pd.concat(parts)
pool.close()
pool.join()
return df
def test_min_cost_flow_pixel():
input_signal_U = np.asfortranarray(np.array([[1.0, 2.0, 3.0, 4.0, 5.0],
[2.0, 3.0, 2.0, 1.0, 4.0],
[5.0, 2.0, 2.0, 4.0, 3.0],
[8.0, 8.0, 3.0, 2.0, 5.0],
[2.0, 3.0, 2.0, 1.0, 4.0],
[5.0, 2.0, 2.0, 4.0, 3.0]]),
dtype=project_float)
graph = build_graph([3, 2], [2, 2])
prox = lsd.min_cost_flow(input_signal_U, graph, 0.1)
eq(
prox,
np.array([[1.0, 2.0, 2.9, 3.95, 4.9], [2.0, 3.0, 2.0, 1.0, 4.0],
[5.0, 2.0, 2.0, 3.95, 3.0], [7.8, 7.8, 2.9, 1.9, 4.9],
[2.0, 3.0, 2.0, 1.0, 4.0], [5.0, 2.0, 2.0, 4.0, 3.0]],
dtype=project_float))
def graphs():
"""
Plot a graph of historic data and model predictions.
"""
# Get historic data used to train a model and model predictions
x = model.data
y = model.predict(output=1, denormalized=True, return_dict=True)
# Pre-process predictions
y = pd.DataFrame(y)
# Rename the column 'prediction' into 'close' in order to conform with
# column naming of the original data
y.rename(columns={'prediction': 'close'}, inplace=True)
# Select only two columns that both historic observations and predictions share in common
# Sort observations from the earliest date to the latest in order to conform with predictions format
x = x[['date', 'close']].sort_values(by=['date'], ascending=True)
graph_url = build_graph(x, y)
return render_template('graphs.html', graph=graph_url)
sigma = float(sys.argv[1])
K = float(sys.argv[3])
min_size = int(sys.argv[4])
size = image_file.size
print 'Image info: ', image_file.format, size, image_file.mode
grid = gaussian_grid(sigma)
if image_file.mode == 'RGB':
# image_file.load() # Useless
r, g, b = image_file.split()
r = filter_image(r, grid)
g = filter_image(g, grid)
b = filter_image(b, grid)
smooth = (r, g, b)
diff = diff_rgb # function pointer
else:
smooth = filter_image(image_file, grid)
diff = diff_grey # function pointer
graph = build_graph(smooth, size[0], size[1], diff, neighbor == 8)
forest = segment_graph(graph, size[0]*size[1], K, min_size, threshold)
image = generate_image(forest, size[0], size[1])
image.save(sys.argv[6])
print 'Number of components: %d' % forest.num_sets
