def test_descr1():
meshes = ['29', '36', '29']
meshes = [OffFile('./meshes/{}.off'.format(mid)).read() for mid in meshes]
seg_meshes = []
for m in meshes:
sg = Segmentation(m)
sg.reduce_to_k_segments(2)
for seg in sg.segments:
seg_meshes.append(seg.mesh)
meshes = seg_meshes
for i in range(1, 2):
scales = [1.0 for x in range(i)]
m_meshes = [m.copy() for m in meshes]
evals = [m.scale_principal_eigenvalues(scales) for m in m_meshes]
descriptors = [
D2Descriptor(m, max_size=5.0, n_samples=1024 * 100)
for m in m_meshes
]
for d in descriptors:
d.plot()
plt.show()
l = len(descriptors)
dists = np.zeros((l, l))
for i in range(len(descriptors)):
for j in range(len(descriptors)):
dists[i][j] = d_dist(descriptors[i], descriptors[j])
print dists
def paint_seg_xz(self):
from matplotlib import rcParams
# rcParams['font.family'] = 'sans-serif'
plt.rcParams["font.family"] = "Times New Roman"
font = {'family' : 'normal',
# 'weight' : 'bold',
'size' : 14}
plt.rc('font', **font)
seg = Segmentation(self.full_traj, self.dfull_traj, self.ddfull_traj)
stroke2 = seg.segmentate_two()[1]
vel, acc = get_vel_and_acc(stroke2, self.freq)
goal_error = 0.1
good_dmp = dmp_process(200, stroke2, vel, acc, 0, goal_error, True)
bad_dmp = dmp_process(200, stroke2, vel, acc, 0, goal_error, false)
plt.figure(1)
plt.plot((1/self.freq)*np.arange(len(stroke2[0])), [-i for i in stroke2[0]], "b", label='ground truth', linewidth=5, alpha=0.6)
plt.plot((1/self.freq)*np.arange(len(stroke2[0])), [-i for i in good_dmp[0]], "r", label='DMP*')
plt.xlabel('t(s)')
plt.ylabel('x(m)')
# plt.title('x/m coordinate changing with time/sec')
plt.legend(loc='upper right', frameon=False)
# plt.savefig('/home/jingwu/Desktop/CS8803/Project/Dec/dmp_compare/%s'% name1)
plt.interactive(False)
plt.show()
def run( self, u_info ):
# self, mojo_dir, tmp_dir, /// out_dir, dojoserver
# register two data sources
self.__segmentation = Segmentation( u_info.files_path , u_info.tmpdir, self)
self.__image = Image( u_info.files_path , u_info.tmpdir)
# and the controller
self.__controller = Controller( u_info, self.__segmentation.get_database(), self ) ####
# and the viewer
self.__viewer = Viewer()
# and the controller
if self.__segmentation:
db = self.__segmentation.get_database()
else:
db = None
self.__controller = Controller( u_info, db, self )
# and the setup
self.__setup = Setup(self, u_info.files_path, u_info.tmpdir)
print('path_gfx: ',path_gfx)
# running live
####
asyncio.set_event_loop(u_info.worker_loop)
dojo = tornado.web.Application([
(r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, {'path': path_gfx}),
(r'/ws', Websockets, dict(controller=self.__controller)),
(r'/(.*)', DojoHandler, dict(logic=self))
],debug=True,autoreload=True) # (r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, {'path': '/dojo/gfx'})
# dojo.listen(u_info.port, max_buffer_size=1024*1024*150000)
server = tornado.httpserver.HTTPServer(dojo)
server.listen(u_info.port)
print('*'*80)
print('*', 'DOJO RUNNING')
print('*')
print('*', 'open', '[ http://' + u_info.ip + ':' + str(u_info.port) + '/dojo/ ] ')
print('*'*80)
tornado.ioloop.IOLoop.instance().start()
server.stop()
# def sig_handler(signum, frame):
# IOLoop.current().add_callback_from_signal(receiver.shutdown)
print("Tornado web server stops.")
return
def train():
feature_mapper = FeatureMapper()
score = Score()
segmentation = Segmentation()
feature_mapper.load_weights("./immutable_weights/feature_mapper")
# score.load_weights("./weights/score")
# segmentation.load_weights("./weights/segmentation")
opt = Adam(learning_rate=5e-5)
with open("../data/data_classification_train.json") as json_file:
data = json.load(json_file)
data_index = 0
while str(data_index) in data:
img = get_img(
"../pictures/pictures_classification_train/{}.png".format(
data_index))
true_masks = get_true_mask(data[str(data_index)])
features = feature_mapper(img)
def get_loss():
segmentation_prediction = segmentation(features)
score_prediction = score(features)
show_evaluation(segmentation_prediction, true_masks, data_index)
return calculate_loss(segmentation_prediction, score_prediction,
true_masks)
opt.minimize(get_loss,
[score.trainable_weights, segmentation.trainable_weights])
if (data_index % 100 == 99):
score.save_weights("./weights/score")
segmentation.save_weights("./weights/segmentation")
data_index += 1
def read(self, consumer, offset, size):
"""I am the main entry point, from which FileNode.read() can get
data. I feed the consumer with the desired range of ciphertext. I
return a Deferred that fires (with the consumer) when the read is
finished.
Note that there is no notion of a 'file pointer': each call to read()
uses an independent offset= value.
"""
# for concurrent operations: each gets its own Segmentation manager
if size is None:
size = self._verifycap.size
# ignore overruns: clip size so offset+size does not go past EOF, and
# so size is not negative (which indicates that offset >= EOF)
size = max(0, min(size, self._verifycap.size - offset))
read_ev = self._download_status.add_read_event(offset, size, now())
if IDownloadStatusHandlingConsumer.providedBy(consumer):
consumer.set_download_status_read_event(read_ev)
consumer.set_download_status(self._download_status)
lp = log.msg(format="imm Node(%(si)s).read(%(offset)d, %(size)d)",
si=base32.b2a(self._verifycap.storage_index)[:8],
offset=offset,
size=size,
level=log.OPERATIONAL,
parent=self._lp,
umid="l3j3Ww")
if self._history:
sp = self._history.stats_provider
sp.count("downloader.files_downloaded", 1) # really read() calls
sp.count("downloader.bytes_downloaded", size)
if size == 0:
read_ev.finished(now())
# no data, so no producer, so no register/unregisterProducer
return defer.succeed(consumer)
# for concurrent operations, each read() gets its own Segmentation
# manager
s = Segmentation(self, offset, size, consumer, read_ev, lp)
# this raises an interesting question: what segments to fetch? if
# offset=0, always fetch the first segment, and then allow
# Segmentation to be responsible for pulling the subsequent ones if
# the first wasn't large enough. If offset>0, we're going to need an
# extra roundtrip to get the UEB (and therefore the segment size)
# before we can figure out which segment to get. TODO: allow the
# offset-table-guessing code (which starts by guessing the segsize)
# to assist the offset>0 process.
d = s.start()
def _done(res):
read_ev.finished(now())
return res
d.addBoth(_done)
return d
def convert_to_segmentation_schema(filename, segmentation):
# Create a segmentation object to serialize
seg_schema = Segmentation()
seg_schema.media.filename = filename
# For each segment returned by the ina_speech_segmenter, add
# a corresponding segment formatted to json spec
for segment in segmentation:
seg_schema.addSegment(segment[0], segment[0], float(segment[1]),
float(segment[2]))
return seg_schema
def create_letter(self):
seg = Segmentation(self.full_traj, self.dfull_traj, self.ddfull_traj)
strokes = seg.segmentate_two()
# create p
for stroke in strokes:
vel, acc = get_vel_and_acc(stroke, self.freq)
if strokes.index(stroke) == 0:
dmp_stroke = dmp_process(200, stroke, vel, acc)
generate_data(dmp_stroke, self.name+"1")
if strokes.index(stroke) == 1:
z_change = dmp_process(200, stroke, vel, acc, 0, 0.15)
dmp_stroke = dmp_process(200, stroke, vel, acc)
dmp_stroke[2] = z_change[2]
generate_data(dmp_stroke, self.name+"2")
# plt.plot([ -i for i in stroke[0]], stroke[2], label='stroke %d' % strokes.index(stroke), linewidth=5, alpha=0.6)
plt.plot([ -i for i in dmp_stroke[0]], dmp_stroke[2], label='DMP_stroke %d' % strokes.index(stroke))
# create B
# for stroke in strokes:
# vel, acc = get_vel_and_acc(stroke, self.freq)
# if strokes.index(stroke) == 0:
# dmp_stroke = dmp_process(200, stroke, vel, acc)
# if strokes.index(stroke) == 1:
# z_change = dmp_process(200, stroke, vel, acc, 0, 0.15)
# dmp_stroke = dmp_process(200, stroke, vel, acc)
# dmp_stroke[2] = z_change[2]
# # plt.plot([ -i for i in stroke[0]], stroke[2], label='stroke %d' % strokes.index(stroke), linewidth=5, alpha=0.6)
# plt.plot([ -i for i in dmp_stroke[0]], dmp_stroke[2], label='DMP_stroke %d' % strokes.index(stroke))
# zz_change = dmp_process(200, strokes[-1], vel, acc, -0.15, 0)
# dmp_stroke2 = dmp_process(200, strokes[-1], vel, acc)
# dmp_stroke2[2] = zz_change[2]
# plt.plot([ -i for i in dmp_stroke2[0]], dmp_stroke2[2], label='DMP_stroke 3')
# create D
# for stroke in strokes:
# vel, acc = get_vel_and_acc(stroke, self.freq)
# zdmp_stroke = dmp_process(200, stroke, vel, acc, 0.0, -0.1)
# xdmp_stroke = dmp_process(200, stroke, vel, acc, 0.0, 0.1)
# plt.plot([ -i for i in xdmp_stroke[0]], zdmp_stroke[2], label='DMP_stroke %d' % strokes.index(stroke))
plt.xticks(np.arange(0.35, 0.70, step=0.05))
plt.yticks(np.arange(0.10, 0.40, step=0.05))
plt.xlabel('x(m)')
plt.ylabel('y(m)')
# plt.title('Create new letter by DMP of writing belongs to %s' % self.name[2:])
plt.legend(loc='upper right', frameon=False)
# plt.savefig('/home/jingwu/Desktop/CS8803/Project/Dec/%s_new_letter.png' % self.name)
# plt.savefig('/home/jingwu/Desktop/CS8803/Project/Dec/%s_B.png')
plt.show()
def read(self, consumer, offset, size):
"""I am the main entry point, from which FileNode.read() can get
data. I feed the consumer with the desired range of ciphertext. I
return a Deferred that fires (with the consumer) when the read is
finished.
Note that there is no notion of a 'file pointer': each call to read()
uses an independent offset= value.
"""
# for concurrent operations: each gets its own Segmentation manager
if size is None:
size = self._verifycap.size
# ignore overruns: clip size so offset+size does not go past EOF, and
# so size is not negative (which indicates that offset >= EOF)
size = max(0, min(size, self._verifycap.size-offset))
read_ev = self._download_status.add_read_event(offset, size, now())
if IDownloadStatusHandlingConsumer.providedBy(consumer):
consumer.set_download_status_read_event(read_ev)
consumer.set_download_status(self._download_status)
lp = log.msg(format="imm Node(%(si)s).read(%(offset)d, %(size)d)",
si=base32.b2a(self._verifycap.storage_index)[:8],
offset=offset, size=size,
level=log.OPERATIONAL, parent=self._lp, umid="l3j3Ww")
if self._history:
sp = self._history.stats_provider
sp.count("downloader.files_downloaded", 1) # really read() calls
sp.count("downloader.bytes_downloaded", size)
if size == 0:
read_ev.finished(now())
# no data, so no producer, so no register/unregisterProducer
return defer.succeed(consumer)
# for concurrent operations, each read() gets its own Segmentation
# manager
s = Segmentation(self, offset, size, consumer, read_ev, lp)
# this raises an interesting question: what segments to fetch? if
# offset=0, always fetch the first segment, and then allow
# Segmentation to be responsible for pulling the subsequent ones if
# the first wasn't large enough. If offset>0, we're going to need an
# extra roundtrip to get the UEB (and therefore the segment size)
# before we can figure out which segment to get. TODO: allow the
# offset-table-guessing code (which starts by guessing the segsize)
# to assist the offset>0 process.
d = s.start()
def _done(res):
read_ev.finished(now())
return res
d.addBoth(_done)
return d
class Gui:
seg = None
app = wx.App()
win = wx.Frame(None, title="Chinese words segmentation", size=(600, 300))
panel = wx.Panel(win)
btnSegment = wx.Button(panel, label="Segment")
txtSentence = wx.TextCtrl(panel)
txtResult = wx.TextCtrl(panel, style=wx.TE_MULTILINE | wx.VSCROLL)
def __init__(self):
self.seg = Segmentation(self)
#load the dict
self.load()
#LOOP
self.init_gui()
def load(self):
self.seg.read_file()
def segment(self, event):
self.txtResult.Clear()
sentence = self.txtSentence.GetValue()
result = self.seg.get_segmentation(sentence)
self.txtResult.SetValue(result)
def onKeyPressed(self, event):
keycode = event.GetKeyCode()
#if ENTER pressed
if keycode == 13:
self.segment(event)
def init_gui(self):
self.btnSegment.Bind(wx.EVT_BUTTON, self.segment)
self.txtSentence.Bind(wx.EVT_KEY_UP, self.onKeyPressed)
hbox = wx.BoxSizer()
hbox.Add(self.txtSentence, proportion=1, flag=wx.EXPAND)
hbox.Add(self.btnSegment, proportion=0, flag=wx.LEFT, border=5)
vbox = wx.BoxSizer(wx.VERTICAL)
vbox.Add(hbox, proportion=0, flag=wx.EXPAND | wx.ALL, border=5)
vbox.Add(self.txtResult,
proportion=1,
flag=wx.EXPAND | wx.LEFT | wx.BOTTOM | wx.RIGHT,
border=5)
self.panel.SetSizer(vbox)
self.win.Center()
self.win.Show()
self.app.MainLoop()
def process_data(folder_name):
for _k in xrange(_K):
data_dir = os.listdir("..//" + folder_name + "/" + str(_k))
for label in data_dir:
for sample in os.listdir("..//" + folder_name + "/" + str(_k) + "/" + label):
if not str(sample).endswith(".txt"):
continue
file = open("..//" + folder_name + "/" + label + "/" + sample, 'r')
content = file.read()
file.close()
segmentation = Segmentation()
token_list = segmentation.cut(content)
write_to_file("..//" + folder_name + "_tokens/" + str(_k) + "/" + label, sample, token_list,
label)
def create_segmentation(self):
"""Generate the segmentation analysis from the audio file. The new
analysis is saved as a png file and also it is saved the oracle created
by vmo."""
if self.audio_path.get():
if self.output_path.get():
self.segmentation = Segmentation(self.audio_path.get())
self.segmentation.output_png(self.segmentation_png)
self.segmentation.save_oracle(self.oracle_path)
self.message_info("Segmentation done")
else:
self.message_error("Set output path")
else:
self.message_error("Set the audio file path")
def generate_patches(filepath, n_segments):
path, filename = os.path.split(filepath)
m = OffFile('./meshes/{}/{}.off'.format(path, filename)).read()
patch_seg = None
sf = SegFile('./patches/{}/{}_patches.seg'.format(path, filename))
if os.path.isfile('./patches/{}/{}_patches.seg'.format(path, filename)):
patch_seg = sf.read(m)
else:
if not os.path.exists('./patches/{}'.format(path)):
os.makedirs('./patches/{}'.format(path))
patch_seg = Segmentation(m)
patch_seg.reduce_to_k_segments(n_segments)
sf.write(patch_seg)
return m, patch_seg
class Gui:
seg = None
app = wx.App()
win = wx.Frame(None, title = "Chinese words segmentation", size = (600, 300))
panel = wx.Panel(win)
btnSegment = wx.Button(panel, label = "Segment")
txtSentence = wx.TextCtrl(panel)
txtResult = wx.TextCtrl(panel, style = wx.TE_MULTILINE | wx.VSCROLL)
def __init__(self):
self.seg = Segmentation(self)
#load the dict
self.load()
#LOOP
self.init_gui()
def load(self):
self.seg.read_file()
def segment(self, event):
self.txtResult.Clear()
sentence = self.txtSentence.GetValue()
result = self.seg.get_segmentation(sentence)
self.txtResult.SetValue(result)
def onKeyPressed(self, event):
keycode = event.GetKeyCode()
#if ENTER pressed
if keycode == 13:
self.segment(event)
def init_gui(self):
self.btnSegment.Bind(wx.EVT_BUTTON, self.segment)
self.txtSentence.Bind(wx.EVT_KEY_UP, self.onKeyPressed)
hbox = wx.BoxSizer()
hbox.Add(self.txtSentence, proportion = 1, flag = wx.EXPAND)
hbox.Add(self.btnSegment, proportion = 0, flag = wx.LEFT, border = 5)
vbox = wx.BoxSizer(wx.VERTICAL)
vbox.Add(hbox, proportion = 0, flag = wx.EXPAND | wx.ALL, border = 5)
vbox.Add(self.txtResult, proportion = 1, flag = wx.EXPAND | wx.LEFT | wx.BOTTOM | wx.RIGHT, border = 5)
self.panel.SetSizer(vbox)
self.win.Center()
self.win.Show()
self.app.MainLoop()
def convert_to_segmentation_schema(filename, segmentation):
media = SegmentationMedia()
media.filename = filename
# Create a segmentation object to serialize
seg_schema = Segmentation(media=media)
# For each segment returned by the ina_speech_segmenter, add
# a corresponding segment formatted to json spec
row = 0
for segment in segmentation:
row += 1
if row == 1:
continue
seg_schema.addSegment(segment[0], segment[0], float(segment[1]),
float(segment[2]))
return seg_schema
def paint_segment(self):
seg = Segmentation(self.full_traj, self.dfull_traj, self.ddfull_traj)
strokes = seg.segmentate_two()
for stroke in strokes:
vel, acc = get_vel_and_acc(stroke, self.freq)
dmp_stroke = dmp_process(100, stroke, vel, acc)
plt.plot([ -i for i in stroke[0]], stroke[2], label='stroke %d' % strokes.index(stroke), linewidth=5, alpha=0.6)
plt.plot([ -i for i in dmp_stroke[0]], stroke[2], label='DMP_stroke %d' % strokes.index(stroke))
plt.xticks(np.arange(0.45, 0.65, step=0.05))
plt.yticks(np.arange(0.25, 0.40, step=0.05))
plt.xlabel('X/m')
plt.ylabel('Y/m')
plt.title('Segmentated trajectory and trajectory computed by DMP of writing belongs to %s' % self.name[2:])
plt.legend(loc='upper right', frameon=False)
# plt.savefig('/home/jingwu/Desktop/CS8803/Project/Dec/segment/%s_segment.png' % self.name)
plt.show()
def read(self, mesh):
"""Reads in the .seg file and returns a Segmentation using the
associated mesh.
Parameters
----------
mesh : :obj:`Mesh3D`
The 3D mesh associated with this segmentation.
Returns
-------
:obj:`Segmentation`
A segmentation created from the given mesh and the .seg file.
"""
f = open(self.filepath_, 'r')
face_to_segment = []
for line in f:
vals = line.split()
if len(vals) > 0:
val = int(vals[0])
face_to_segment.append(val)
f.close()
return Segmentation(mesh, face_to_segment)
def run_unet_resnet(istrain=False, tissue='liver', batch_size=8):
return Segmentation.run_liver(
istrain=istrain,
model_name='unet_resnet',
modelcheckpoint='cache/{0}/model/unet_resnet.hdf5'.format(tissue),
batch_size=batch_size,
nb_epoch=50,
isliver=True if tissue == 'liver' else False)
def run_unet_gen_448_448_padecho(istrain=False):
return Segmentation.run_breast(
istrain=istrain,
model_name='unet5',
modelcheckpoint='cache/breast/model/unet_gen_448_448_padecho.hdf5',
batch_size=16,
is_datagen=True,
images_npy='cache/breast/datasets/images_pad_echo_448_448_tf.npy',
masks_npy='cache/breast/datasets/masks_pad_echo_448_448_tf.npy')
def segmentate(G, V, k=0.1):
"""
Method to segmentate a given weighted undirected Graph w.r.t a threshold
function depending on the factor k.
Args:
G: weighted undirected Graph
V: list of vertices (ordered!!)
k: threshold factor
"""
E = G.edges(data="weight")
print "STATUS: sorting edges"
E = sorted(E, key=lambda x: x[2])
seg = Segmentation(len(V), k=k)
print "STATUS: running segmentation"
for e in E:
(v1, v2, w) = e
i = V.index(v1)
j = V.index(v2)
if w <= seg.MInt(i, j):
seg.union(i, j, weight=w)
return seg
def predict_image(im_path):
plankton = Segmentation(im_path, target_shape=(75, 75, 3))
plankton.segment()
padded = plankton.get_padded()
feat = plankton.get_features()
feat = np.array(feat)
padded = preprocess_input(np.array(padded, dtype=np.float32))
x_img = padded.reshape(1, padded.shape[0], padded.shape[1], padded.shape[2])
x_feat = feat.reshape(1, feat.shape[0])
x_feat = mms.transform(x_feat)
y_hat = model.predict([x_img, x_feat])
valid = False
labels = {}
results = []
for i, y in enumerate(y_hat.flatten()):
if y > 0.5:
valid = True
labels[i] = y
if valid:
#sort by value. lower prob to higher prob. (given it is above threshold prob)
labels = sorted(labels.items(), key=lambda x: x[1], reverse=False)
save_image(im_path, labels)
label_hat = class_map[labels[0][0]]
y_hat = [str(x) for x in y_hat.flatten()]
results.append(im_path)
results.append(label_hat)
results.extend(y_hat)
return results
return None
def segment_all(one_obj_path, output_path):
for image in glob.glob(one_obj_path + "input/*"):
name = image[len(one_obj_path + "input/"):-4]
print("processing {}".format(name))
#fg = image.replace("input/", "output_fg/").replace(".jpg", ".png")
#bg = image.replace("input/", "output_bg/").replace(".jpg", ".png")
masks = []
im = prepare_image(image)
#fg = prepare_image(fg)
#bg = prepare_image(bg)
fg = None
bg = None
for i in range(5):
s = Segmentation("1obj_{}".format(i) + name,
im,
bg_hint=bg,
fg_hint=fg,
plot_during_training=True,
output_path=output_path)
s.optimize()
masks.append(s.best_result.mask)
save_image("1obj_" + name + "_final_mask", median(masks), output_path)
def process(self, frame, name="TrainingSamples/Image_"):
# preprocessing for contour detection
preprocessed = PreProcessing().background_contour_removal(frame)
# find contours using algorithm by Suzuki et al. (1985)
contours, hierarchy = cv.findContours(preprocessed, cv.RETR_TREE,
cv.CHAIN_APPROX_NONE)
# limit observed contours
if len(contours) > 500:
contours = contours[:500]
# ignore first contour, as it is outer border of the frame
contours = contours[1:]
hierarchy = hierarchy[0][1:] - 1
hierarchy = np.where(hierarchy < 0, -1, hierarchy)
if len(contours) == 0:
return preprocessed
# initialize contour object from each contour in contour list
binarized = PreProcessing().custom_binarize(frame)
contourList = [
Contour(contour=cnt, imgShape=frame.shape, frameBinary=binarized)
for cnt in contours
]
# filter, classify and group segmented contours
sg = Segmentation(contourList, hierarchy, frame.shape)
sg.group_and_classify()
filtered = sg.get_contours()
if len(filtered) == 0:
return preprocessed
# colouring preprocessing for ease in debugging
preprocessed = cv.cvtColor(preprocessed, cv.COLOR_GRAY2BGR)
lines = LineOrdering(filtered).get_lines(frame)
# label contours with additional positional information
lines = sg.label_contours(lines)
for l in range(len(lines)):
line = lines[l]
for i in range(len(line)):
cnt = line[i]
cv.putText(frame,
str(l) + str(i), (cnt.center[0], cnt.center[1]),
cv.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 1)
solutions = [
self.solver.solve([cnt.unwrap() for cnt in line], frame)
for line in lines if len(line) > 2
]
return preprocessed # orderedImage
def main():
(input_file, input_segmentation_json, remove_type, output_file,
kept_segments_file) = sys.argv[1:6]
# Turn segmentation json file into segmentation object
with open(input_segmentation_json, 'r') as file:
seg_data = Segmentation().from_json(json.load(file))
# Remove silence and get a list of kept segments
kept_segments = remove_silence(remove_type, seg_data, input_file,
output_file)
# Write kept segments to json file
mgm_utils.write_json_file(kept_segments, kept_segments_file)
exit(0)
def run_unet(istrain=False,
tissue='liver',
batch_size=8,
image_size=(512, 512),
model_pretrain=None):
return Segmentation.run_liver(
istrain=istrain,
model_name='unet',
modelcheckpoint='cache/{0}/model/unet_{1}.hdf5'.format(
tissue, image_size[0]),
batch_size=batch_size,
nb_epoch=50,
model_pretrain=model_pretrain,
isliver=True if tissue == 'liver' else False,
image_size=image_size)
def __init__(self, parent=None):
super(StartQT4, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#self.ui.web.page().mainFrame().addToJavaScriptWindowObject('self', self)
#self.ui.web.setHtml(getHTML(lat, lon))
self.ui.web.setHtml(html)
self.ui.web.page().settings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, True)
inspector = QWebInspector()
inspector.setPage(self.ui.web.page())
inspector.setVisible(True)
self.ui.web.page().loadFinished.connect(self.load_finished)
# here we connect signals with our slots
self.ctimer = QtCore.QTimer()
QtCore.QObject.connect(self.ctimer, QtCore.SIGNAL('timeout()'),
self.ctimerloop)
self.ui.okButton.clicked.connect(self.onClick)
self.imagesParser = ImageInfoParser()
self.readgoogleimages = ReadGoogleImages()
self.segmentation = Segmentation()
def main():
(input_file, input_segmentation_json, remove_type, output_file, kept_segments_file) = sys.argv[1:6]
print("Reading segmentation file")
# Turn segmentation json file into segmentation object
with open(input_segmentation_json, 'r') as file:
seg_data = Segmentation().from_json(json.load(file))
print("Removing silence to get a list of kept segments")
# Remove silence and get a list of kept segments
kept_segments = remove_silence(remove_type, seg_data, input_file, output_file)
print("Writing output json file")
# Write kept segments to json file
write_kept_segments_json(kept_segments, kept_segments_file)
exit(0)
def _test():
from segmentation import Segmentation
import input_output
s = Segmentation(5)
c1 = Nuage(input_output.get_clouds([0], 1, size=.01)[0], s)
c2 = torch.tensor([[0., 0, 0], [1, 1, 1], [-1, -1, -1], [.2, .3, .0]])
c2 = Nuage(c2, s)
n_mlp = 2
latent_size = 25088
grid_points = 4
epochs = 5
latent = input_output.get_latent([0], 1, nPerObj=1)[0]
# équivalence des deux fonctions de loss (avec points écrits à la main)
print("seg", Nuage.chamfer_seg(c1, c2))
print("quad", Nuage.chamfer_quad(c1.liste_points, c2.liste_points))
assert Nuage.chamfer_seg(c1,
c2) == Nuage.chamfer_quad(c1.liste_points,
c2.liste_points)
# presque équivalence de convergence
# (utilise les mêmes nombres aléatoires pour avoir le même résultat)
torch.manual_seed(0)
np.random.seed(0)
reconstructeur1 = Reconstructeur(n_mlp,
latent_size,
grid_points,
s,
quadratic=False)
torch.manual_seed(0)
np.random.seed(0)
reconstructeur2 = Reconstructeur(n_mlp,
latent_size,
grid_points,
s,
quadratic=True)
res1 = fit_reconstructeur(reconstructeur1, ([latent], [c1]), epochs)
print()
res2 = fit_reconstructeur(reconstructeur2, ([latent], [c1]), epochs)
# différences sûrement dues à des erreurs d'arrondi
assert np.all(
np.abs(np.array(res1["loss_train"]) -
np.array(res2["loss_train"])) < 1e-3)
print("tests passés")
def error(coords_list):
seeds = fixed_seeds.copy()
print(f'coordinate list : {coords_list}')
print(f'seeds : {seeds}')
for index in range(len(coords_list) // 2):
coordinate = (int(coords_list[2 * index]),
int(coords_list[2 * index + 1]))
seeds.update({coordinate: colour})
segmentation = Segmentation(image_array,
beta,
seeds,
image_name,
reference_path=target_segmentation_path)
segmentation.solve()
segmentation.build_segmentation_image()
return segmentation.compute_error()
def main():
(segmentation_json, adj_json, output_json) = sys.argv[1:4]
# Turn adjustment data into list of kept segments
with open(adj_json, 'r') as file:
adj_data = json.load(file)
# Turn segmentation json into objects
with open(segmentation_json, 'r') as file:
seg = Segmentation().from_json(json.load(file))
# List of adjustments (start, end, adjustment)
offset_adj = []
# Last ending position for iterating through kept segments
last_end = 0.00
# Running tally of removed segment lengths
current_adj = 0.00
# For each segment that was kept, keep track of the gaps to know how much to adjust
for kept_segment in adj_data:
print(kept_segment + ":" + str(adj_data[kept_segment]))
start = float(kept_segment)
end = adj_data[kept_segment]
# If the start of this segment is after the last end, we have a gap
if (start >= last_end):
# Keep track of the gap in segments
current_adj = current_adj + (start - last_end)
# Add it to a list of adjustments
offset_adj.append(
Adjustment(start - current_adj, end - current_adj,
current_adj))
# Keep track of the last segment end
last_end = end
print("#OFFSET ADJUSTMENTS")
for adj in offset_adj:
print(str(adj.start) + ":" + str(adj.end) + ":" + str(adj.adjustment))
# For each word, find the corresponding adjustment
for segment in seg.segments:
adjust_segment(segment, offset_adj)
# Write the resulting json
mgm_utils.write_json_file(seg, output_json)
def make_prediction():
txt = request.get_json()['text']
model.eval()
# Clean the data from the raw input
sentence = clean_data(np.array([txt]))
# Segment and tokenize the clean data
tokenized = [
TOKENIZER(t) for t in Segmentation(sentence).runSegmentation()
]
indexed = [TEXT.vocab.stoi[t] for t in tokenized[0]]
length = [len(indexed)]
tensor = torch.LongTensor(indexed).unsqueeze(1)
length_tensor = torch.LongTensor(length)
prediction = torch.sigmoid(model(tensor, length_tensor))
result = {'text': txt, 'label': prediction.item()}
session.append(result)
return jsonify({'result': result})
def predict_image(im_path):
plankton = Segmentation(im_path, target_shape=(75, 75, 3))
plankton.segment()
padded = plankton.get_padded()
feat = plankton.get_features()
feat = np.array(feat)
padded = preprocess_input(np.array(padded, dtype=np.float32))
x_img = padded.reshape(1, padded.shape[0], padded.shape[1],
padded.shape[2])
x_feat = feat.reshape(1, feat.shape[0])
x_feat = mms.transform(x_feat)
y_hat = model.predict([x_img, x_feat])
label_hat = class_map[np.argmax(y_hat)]
save_image(im_path, y_hat)
y_hat = [str(x) for x in y_hat.flatten()]
results = []
results.append(im_path)
results.append(label_hat)
results.extend(y_hat)
return results
parser.add_argument('--num_points',
type=int,
default=2048,
help='Num of points to use')
parser.add_argument('--model_path',
type=str,
default='',
metavar='N',
help='Path to load model')
args = parser.parse_args()
return args
if __name__ == '__main__':
args = get_parser()
if args.eval == False:
if args.task == 'reconstruct':
reconstruction = Reconstruction(args)
reconstruction.run()
elif args.task == 'classify':
classification = Classification(args)
classification.run()
elif args.task == 'segment':
segmentation = Segmentation(args)
segmentation.run()
else:
inference = Inference(args)
feature_dir = inference.run()
svm = SVM(feature_dir)
svm.run()
def __init__(self):
self.seg = Segmentation(self)
#load the dict
self.load()
#LOOP
self.init_gui()
