def test(self, feature_data = None):
#test on current scan:
print ut.getTime(), 'test on:', self.processor.scan_dataset.id
if feature_data == None:
filename = self.processor.get_features_filename()
dict = ut.load_pickle(filename)
else:
dict = feature_data
baseline_labels = self.classify_baseline_code()
return baseline_labels, self.test_results(dict, baseline_labels)
def run(func, args):
messages = {
trucks: "import trucks ",
compute: "compute truck dates and centers ",
stops: "compute stops and properties"
}
message = messages[func]
try:
getTime(func, message, *args)
# func(*args)
#notify(message)
except:
print traceback.format_exc()
notify(message + "failed")
def __init__(self, config_file=None, runmode="local"):
self.start_time = time.time()
self.config = updateConfig(DEFAULT_CONFIG, config_file)
self.runmode = runmode
self.client_name = "client_%s_%s" % (runmode,
randString(self.config['client_uid_length']))
self.client_dir = os.path.join(self.config['base_dir'], self.client_name)
self.create_client_dir()
self.logger = Logger(os.path.join(self.client_dir, "log.txt"), "a")
sys.stdout = self.logger
sys.stderr = self.logger
print "[%s][%s] Starting client with following config:" % (getTime(),
self.client_name)
pprint.pprint(self.config, indent=2); print
my_queue = ShortestTaskQueue if self.config['runmode'] == "hybrid" else FIFOQueue
self.submit_queue = my_queue(queue_dir=os.path.join(self.config['base_dir'],
self.config['submit_queue_name']))
self.result_queue = my_queue(queue_dir=os.path.join(self.config['base_dir'],
self.config['result_queue_name']))
self.stop_running = False
self.run()
def train(self):
#cv_boost_params = cv.CvBoostParams()
#priors = cv.cvCreateMat(1,2,cv.CV_32FC1)
#priors[0] = 10
#priors[1] = 1
#cv_boost_params.max_categories = 2
#cv_boost_params.priors = priors #TODO: activate them
self.cv_classifier = cv.CvDTree() #cv.CvBoost() #TODO: CHANGE CLASSIFIER HERE
train_datastructures = self.create_train_datastructures()
(train_data, train_labels, type_mask) = train_datastructures
print 'WARNING! use CvDTree (single decision trees) for now as load/save works!'#'boost'
print ut.getTime(), self.cv_classifier.train(train_data, cv.CV_ROW_SAMPLE, train_labels, None, None, type_mask ) #TODO: CHANGE CLASSIFIER HERE
print ut.getTime(), 'traning finished'
def test(self, feature_data = None):
#test on current scan:
print ut.getTime(), 'test on:', self.processor.scan_dataset.id
if feature_data == None:
filename = self.processor.get_features_filename()
print 'loading', filename
dict = ut.load_pickle(filename)
else:
dict = feature_data
#print ut.getTime(), dict
current_set_size = dict['set_size']
feature_vector_length = len(self.processor.features.get_indexvector(self.features))
print ut.getTime(), feature_vector_length
labels = np.array(np.zeros(len(self.processor.map_polys)))
print 'test: length of labels vector:', len(labels)
test = cv.cvCreateMat(1,feature_vector_length,cv.CV_32FC1)
if current_set_size == 0:
print ut.getTime(), 'ERROR: test dataset is empty!'
return labels, 1, 1, 1
count = 0
for index in dict['point_indices']:
fv = (dict['features'][count])[self.processor.features.get_indexvector(self.features)]
#print ut.getTime(), fv, dict['features'][count]
for fv_index, fv_value in enumerate(fv):
test[fv_index] = fv_value
#print 'class',self.cv_classifier
label = self.cv_classifier.predict(test)
#print label.value
labels[index] = label.value
#print 'tdone'
if count % 4096 == 0:
print ut.getTime(), 'testing:', count, 'of', current_set_size, '(',(float(count)/float(current_set_size)*100.0),'%)'
count += 1
#save for later use for postprocessing:
self.test_feature_dict = dict
self.test_labels = labels
#cv.cvReleaseMat(test)
return labels, self.test_results(dict, labels)
def test_results(self, dict, labels):
current_set_size = dict['set_size']
count_correct = 0
count_clutter_correct = 0
count_surface_correct = 0
count_clutter = 0
count_surface = 0
count = 0
for index in dict['point_indices']:
label = labels[index]
if label == dict['labels'][count]:
count_correct += 1
if dict['labels'][count] == processor.LABEL_CLUTTER:
count_clutter += 1
if label == dict['labels'][count]:
count_clutter_correct += 1
if dict['labels'][count] == processor.LABEL_SURFACE:
count_surface += 1
if label == dict['labels'][count]:
count_surface_correct += 1
count += 1
print ut.getTime(), '##########################################'
print ut.getTime(), '####tested on ', self.features, '###########################'
print ut.getTime(), '==================================='
print ut.getTime(), 'percent in total: surface:',(float(count_surface)/float(current_set_size)*100), '%, clutter:',(float(count_clutter)/float(current_set_size)*100),'%'
print ut.getTime(), '#points surface:',count_surface,'clutter:',count_clutter
print ut.getTime(), '#points correct: surface:',count_surface_correct,'clutter:',count_clutter_correct
if count_surface > 0:
percent_surface_correct = float(count_surface_correct)/float(count_surface) * 100
else:
percent_surface_correct = 100
if count_clutter > 0:
percent_clutter_correct = float(count_clutter_correct)/float(count_clutter) * 100
else:
percent_clutter_correct = 100
print ut.getTime(), '#percent correct: surface:',percent_surface_correct,'clutter:',percent_clutter_correct
print ut.getTime(), '==================================='
print ut.getTime(), '##########################################'
testresults = (count_surface, count_clutter,count_surface_correct, count_clutter_correct, percent_surface_correct, percent_clutter_correct)
return testresults
header = header + "`" + BEGAN_TIME + "--" + END_TIME + "`"
header = header + "\n\n\n"
curBook.header = header
# 向文件添加标注内容
stce_succ_cnt = 0 # 向html文件添加笔记成功次数
stce_fail_cnt = 0 # 向html文件添加笔记失败次数
# print("html name:",os.listdir())
file_list = os.listdir(".") # 获取当前目录文件名，存放于file_list
for j in range(0, sentence.__len__()):
temp = both[j]
filename = "{}{}{}".format(util.changechar(temp[0][0:80]), nowTime,
FILE_SUFFIX)
curBook = findBook(filename, allBooks)
s1 = util.getAddr(temp[1]) # 获取标注位置
s2 = util.getTime(temp[1]) # 获取标注时间
s3 = util.getMark(temp[1]) # 获取标注内容
if s3 != "\n": # 如果文本内容非空
stce_succ_cnt += 1
cnt_temp = stceOfBookCnt[filename]
stceOfBookCnt[filename] = cnt_temp + 1
# senContent = "\n### " + str(cnt_temp + 1) + ". " + s3
senContent = s3
senContent = senContent + "\n " + s2 + " &&" + s1 + "\n"
senContent = senContent + "\n"
curSen = book.Sentence(senContent, util.getBeginPos(s1))
if curBook.hasChapter:
curBook.appendChapterSen(curSen)
else:
curBook.appendSen(curSen)
if curBook.sentenceLen() == 1:
tmp = []
for site in sites:
status_code = 0
text = None
try:
req = requests.get(sites[site], timeout=10)
status_code = req.status_code
tmp.append(status_code)
if status_code != 200:
text = str(req.text)
except Exception as e:
status_code = -1
tmp.append(status_code)
# save bad file
if text != None:
with open('errors/' + util.getTime(format="%Y-%m-%d_%H-%M-%S") + '_' + site + '_' + str(status_code) + '.html', "w") as text_file:
for bc in bad_chars:
text = text.replace(bc, '')
text_file.write(text)
# print to console
out = [str(datetime.now())[:19]] + tmp
util.p('TEST', str(out))
# write to file
with open('data.csv', 'a') as f:
csv_writer = csv.writer(f, delimiter=',', quotechar="'", quoting=csv.QUOTE_MINIMAL, lineterminator = '\n')
csv_writer.writerow(out)
time.sleep(0.999)
files = os.listdir(INPUT_DIR)
if os.path.exists(INPUT_DIR) and len(files) == 0:
print('the directory ' + INPUT_DIR + ' not exists or is empty')
time.sleep(1) # wait for one second
continue
for file in files:
print('processing file: ' + file)
f = open(INPUT_DIR + "/" + file, 'r')
lines = f.readlines()
if len(lines) == 0:
print('file is empty: ' + file)
continue # next file
result = open(SYNTACTIC_RESULT_DIR + "/" + util.getTime() + '_' + file,
'w+')
for line in lines:
doc = nlp(line)
for token in doc:
word = token.text.strip()
word = 'new_line' if word == '' else token.text
result.write(convertToResult(word, token))
print(convertToResult(word, token))
# end token for
# end line for
result.close()
loss = nn.CrossEntropyLoss() # 损失函数选择，交叉熵函数
optimizer = optim.SGD(model.parameters(), lr=0.1)
num_epochs = 10
# 以下四个列表是为了可视化（暂未实现）
losses = []
acces = []
eval_losses = []
eval_acces = []
for echo in range(num_epochs):
train_loss = 0 # 定义训练损失
train_acc = 0 # 定义训练准确度
model.train() # 将网络转化为训练模式
print("startTime = ", util.getTime())
for i, (X, label) in enumerate(train_loader): # 使用枚举函数遍历train_loader
# X = X.view(-1,784) #X:[64,1,28,28] -> [64,784]将X向量展平
if device == "cpu":
X = Variable(X) # 包装tensor用于自动求梯度
label = Variable(label)
else:
X = Variable(X).cuda() # 包装tensor用于自动求梯度
label = Variable(label).cuda()
out = model(X) # 正向传播
lossvalue = loss(out, label) # 求损失值
optimizer.zero_grad() # 优化器梯度归零
lossvalue.backward() # 反向转播，刷新梯度值
optimizer.step() # 优化器运行一步，注意optimizer搜集的是model的参数
# 计算损失
def get_featurevector(self, index, count, pts = None):
if pts == None:
pts = self.processor.pts3d_bound
#print 'i',index,'c', count
fv = []
indices = np.asarray(self.kdtree_queried_indices[count])
invalid_value = np.shape(pts)[1]
#print indices
#print 'iv',invalid_value
indices = indices[indices != invalid_value]
#print ut.getTime(), indices
#print ut.getTime(), 'number of pts', len(indices)
a = pts[:,indices]
view = processor.rotate_to_plane(self.processor.scan_dataset.ground_plane_normal, np.matrix([-1,0,0.]).T)
normal, eigenvalues = gaussian_curvature.gaussian_curvature(a,view)
#eigenvalues = eigenvalues / np.square(r)
#fv += [normal[0,0],0,normal[2,0]]
#fv += normal.T.A[0].tolist()
#fv += eigenvalues.tolist()
#print np.asarray(pts[:,index].T[0])[0]
# print 'pt',np.asarray(pts[:,index].T[0])
point = pts[:,index]
ev1, ev2 = self.get_voi_histogram_spread(point)
#z_max_height_diff = pts[2,index] - self.get_voi_maxcount_height()
#fv += [self.get_voi_histogram_value(point),z_max_height_diff,normal[0,0],normal[1,0],normal[2,0], ev1, ev2]
fv += [self.get_voi_histogram_value(point),normal[0,0],normal[1,0],normal[2,0], ev1, ev2]
h = self.imNP_h[self.processor.map2d[1,index],self.processor.map2d[0,index]]
s = self.imNP_s[self.processor.map2d[1,index],self.processor.map2d[0,index]]
i = self.processor.intensities_bound[index]
hsi = self.get_voi_hsi_histogram_values(point,h,s,i)
fv += [hsi[0],hsi[1],hsi[2]]
#print np.shape(self.imNP_tex1)
#print np.shape(self.map2d)
tex1 = self.imNP_tex1[self.processor.map2d[1,index],self.processor.map2d[0,index]]
tex2 = self.imNP_tex2[self.processor.map2d[1,index],self.processor.map2d[0,index]]
fv += [tex1, tex2]
#print tex1, tex2
#color histograms:
colors_h = []
colors_s = []
colors_v = []
for idx in indices:
colors_h.append(float(self.imNP_h[self.processor.map2d[1,idx],self.processor.map2d[0,idx]]))
colors_s.append(float(self.imNP_s[self.processor.map2d[1,idx],self.processor.map2d[0,idx]]))
colors_v.append(float(self.imNP_v[self.processor.map2d[1,idx],self.processor.map2d[0,idx]]))
color_hist = stats.histogram2(np.array(colors_h), [0,51,102,153,204])
color_hist = color_hist / float(np.sum(color_hist))
color_hist = list(color_hist)
fv += color_hist
color_hist = stats.histogram2(np.array(colors_s), [0,51,102,153,204])
color_hist = color_hist / float(np.sum(color_hist))
color_hist = list(color_hist)
fv += color_hist
color_hist = stats.histogram2(np.array(colors_v), [0,51,102,153,204])
color_hist = color_hist / float(np.sum(color_hist))
color_hist = list(color_hist)
fv += color_hist
#intensities
intensities = self.processor.intensities_bound[indices]
intensities = np.asarray(intensities)
#map to 0-255-range: TODO: perhaps do some nonlinear transformation here?
intensities = intensities / 10000 * 255
intensity_hist = stats.histogram2(intensities, [0,51,102,153,204])
intensity_hist = intensity_hist / float(np.sum(intensity_hist))
intensity_hist = list(intensity_hist)
fv += intensity_hist
#current colors:
fv += [float(self.imNP_h[self.processor.map2d[1,index],self.processor.map2d[0,index]]) / 255.0]
fv += [float(self.imNP_s[self.processor.map2d[1,index],self.processor.map2d[0,index]]) / 255.0]
fv += [float(self.imNP_v[self.processor.map2d[1,index],self.processor.map2d[0,index]]) / 255.0]
#current intensity value (scaled)
intensity = self.processor.intensities_bound[index]
#scale:
intensity = intensity / 15000.0
intensity = [intensity]
fv += intensity
if self.debug_before_first_featurevector == True:
self.debug_before_first_featurevector = False
print ut.getTime(), 'get_featurevector: Choosing not to print Feature Vector Sample'
#print ut.getTime(), 'feature vector sample(gaussian histograms):', fv
return fv
top_id=['s_122', 'f_0062', 'c', 'k']
entainment_id=['f_0055', 's_112', 'k_5']
military_id=['f_0052', 's_122101', 'c_3']
society_id=['s_122102', 'f_0062-0003', 'c_4', 'k_3']
economy_id=['s_122104', 'f_0062-0005', 'k_6']
technogy_id=['s_122106', 'f_0062-0008']
inner_id=['s_122204', 'f_0062-0000', 'c_1', 'k_1']
internation_id=['s_122205', 'f_0062-0001', 'c_2', 'k_2']
sports_id=['s_16', 'f_0062-0006', 'k_4']
taiwan_id=['f_0062-0002', 'f_0052-0001']
property_id=['f_0062-0009']
category = [('top', top_id, 1), ('inner', inner_id, 3), ('military', military_id, 4), ('entainment', entainment_id, 5), ('internation', internation_id, 6),\
('sports', sports_id, 7), ('economy', economy_id, 8), ('society', society_id, 10)]
# category = [('top', top_id, 1)]
##category = [('sports', sports_id, 7)]
now, bef24, bef72 = util.getTime()
# now = '2014-07-30 21:47:20'
# bef24 = '2014-07-29 21:47:20'
# bef72 = '2014-07-27 21:47:20'
def getRes(news_category_id, category_id, category_name):
news_corpus = sql.getNews(news_category_id, now)
sounds_corpus = sql.getSound(category_id, bef72, now)
news, sounds = pre.pre_all(news_corpus, sounds_corpus, now)
index = -1
for i, item in enumerate(sounds):
if item[2] < bef24:
index = i
break
def create_train_datastructures(self):
#loop through all marked datasets
self.processor.scan_dataset = self.processor.scans_database.get_dataset(0)
training_set_size = 0
data = []
#get size of training set in total
while False != self.processor.scan_dataset:
if self.processor.scan_dataset.is_training_set:
filename = self.processor.get_features_filename(True)
print 'loading', filename
dict = ut.load_pickle(filename)
# make an equal size of points for each class: use object labels more often:
difference = np.sum(dict['labels'] == processor.LABEL_SURFACE) - np.sum(dict['labels'] == processor.LABEL_CLUTTER)
#print ut.getTime(), filename
#print ut.getTime(), 'surface',np.sum(dict['labels'] == LABEL_SURFACE)
#print ut.getTime(), 'clutter',np.sum(dict['labels'] == LABEL_CLUTTER)
#print ut.getTime(), difference, "difference = np.sum(dict['labels'] == LABEL_SURFACE) - np.sum(dict['labels'] == LABEL_CLUTTER)"
#print ut.getTime(), ''
if difference > 0:
clutter_features = (dict['features'])[np.nonzero(dict['labels'] == processor.LABEL_CLUTTER)]
if len(clutter_features) > 0: #if there are none, do nothin'
dict['set_size'] += difference
dict['features'] = np.vstack((dict['features'], clutter_features[np.random.randint(0,len(clutter_features),size=difference)]))
dict['labels'] = np.hstack((dict['labels'], np.ones(difference) * processor.LABEL_CLUTTER))
elif difference < 0:
surface_features = (dict['features'])[np.nonzero(dict['labels'] == processor.LABEL_SURFACE)]
if len(surface_features) > 0: #if there are none, do nothin'
difference = -difference
dict['set_size'] += difference
dict['features'] = np.vstack((dict['features'], surface_features[np.random.randint(0,len(surface_features),size=difference)]))
dict['labels'] = np.hstack((dict['labels'], np.ones(difference) * processor.LABEL_SURFACE))
training_set_size += dict['set_size']
data.append(dict)
#get next one
self.processor.scan_dataset = self.processor.scans_database.get_next_dataset()
#print ut.getTime(), self.scan_dataset
#create training set:
self.processor.scan_dataset = self.processor.scans_database.get_dataset(0)
current_training_set_index = 0
feature_vector_length = len(self.processor.features.get_indexvector(self.features))
print ut.getTime(), feature_vector_length
#create dataset matrices:
print ut.getTime(), '#training set size ', training_set_size
#deactivate for now:
max_traning_size = 1800000#2040000
#if training_set_size < max_traning_size:
#if True:
train_data = cv.cvCreateMat(training_set_size,feature_vector_length,cv.CV_32FC1) #CvMat* cvCreateMat(int rows, int cols, int type)
train_labels = cv.cvCreateMat(training_set_size,1,cv.CV_32FC1)
for dict in data:
for index in range(dict['set_size']):
#only train on surface and clutter
if dict['labels'][index] == processor.LABEL_SURFACE or dict['labels'][index]== processor.LABEL_CLUTTER:
#print ut.getTime(), point3d
#print ut.getTime(), 'fvindexv',self.get_features_indexvector(features)
#print ut.getTime(), 'len', len(self.get_features_indexvector(features))
fv = (dict['features'][index])[self.processor.features.get_indexvector(self.features)]
#print ut.getTime(), 'fv',fv
#print ut.getTime(), np.shape(fv)
for fv_index, fv_value in enumerate(fv):
train_data[current_training_set_index][fv_index] = fv_value
train_labels[current_training_set_index] = dict['labels'][index]
# for fv_index, fv_value in enumerate(fv):
# print ut.getTime(), train_data[current_training_set_index][fv_index]
# print ut.getTime(), '##',train_labels[current_training_set_index],'##'
#print ut.getTime(), 'fv ', fv
#print ut.getTime(), 'tr ',train_data[index]
current_training_set_index = current_training_set_index + 1
#if current_training_set_index % 4096 == 0:
# print ut.getTime(), 'label', dict['labels'][index], 'fv', fv
if current_training_set_index % 16384 == 0:
print ut.getTime(), 'reading features:', current_training_set_index, 'of', training_set_size, '(',(float(current_training_set_index)/float(training_set_size)*100.0),'%)'
##subsample from the features, NOT USED/NOT WORKING?
# else:
# print ut.getTime(), 'more than',max_traning_size,'features, sample from them...'
# #select 2040000 features:
# all_data = []
# all_labels = []
# for dict in data:
# for index in range(dict['set_size']):
# if dict['labels'][index] == processor.LABEL_SURFACE or dict['labels'][index]== processor.LABEL_CLUTTER:
# fv = (dict['features'][index])[self.processor.features.get_indexvector(self.features)]
# all_data += [fv]
# all_labels += [dict['labels'][index]]
#
# current_training_set_index = current_training_set_index + 1
# if current_training_set_index % 16384 == 0:
# print ut.getTime(), 'reading features:', current_training_set_index, 'of', training_set_size, '(',(float(current_training_set_index)/float(training_set_size)*100.0),'%)'
#
# del data
# indices = np.array(random.sample(xrange(len(all_labels)),max_traning_size))
# all_data = np.asarray(all_data)
# all_labels = np.asarray(all_labels)
#
# all_data = all_data[indices]
# all_labels = all_labels[indices]
#
# train_data = cv.cvCreateMat(max_traning_size,feature_vector_length,cv.CV_32FC1) #CvMat* cvCreateMat(int rows, int cols, int type)
# train_labels = cv.cvCreateMat(max_traning_size,1,cv.CV_32FC1)
#
# for index in range(max_traning_size):
# for fv_index, fv_value in enumerate(all_data[index]):
# train_data[index][fv_index] = fv_value
# train_labels[index] = all_labels[index]
# if index % 16384 == 0:
# print ut.getTime(), 'setting features:', (float(index)/float(max_traning_size))
#
print ut.getTime(), 'start training Classifier'
type_mask = cv.cvCreateMat(1, feature_vector_length+1, cv.CV_8UC1)
cv.cvSet( type_mask, cv.CV_VAR_NUMERICAL, 0)
type_mask[feature_vector_length] = cv.CV_VAR_CATEGORICAL
return (train_data, train_labels, type_mask)
def load(self):
self.cv_classifier = cv.CvDTree() #cv.CvBoost() #TODO: CHANGE CLASSIFIER HERE
print ut.getTime(), 'loading Classifier',self.features
self.cv_classifier.load(self.get_filename())
def setupAll():
try:
run(trucks, [])
run(compute, [])
run(stops,[])
notify("complete setup succeeded!")
except:
print traceback.format_exc()
notify("complete setup failed...")
##
# deletes the database and cleans up the collections
def dataPurge(db):
client = MongoClient()
client.drop_database(db)
if __name__ == '__main__':
dataPurge(db)
setupAll()
if len(sys.argv) == 2:
if sys.argv[1] == "all":
getTime(setupAll, "Ran complete setup")
if sys.argv[1] == "trucks":
run(trucks, [])
if sys.argv[1] == "stops":
run(stops, [])
if sys.argv[1] == "compute":
run(compute, [])
def run():
"""execute the TraCI control loop"""
traci.init(PORT)
step = 0
timeCount = 0
rushHour = 1
# we start with phase 2 where EW has green
traci.trafficlights.setPhase("0", 2)
evaluator = learningAgents.LearningAgent()
#opening an output file.
fileName = "Output.txt"
outFile = open(fileName, 'w')
"""
Lane IDs:
West to East: 1i_0
East to West: 2i_0
South to North: 3i_0
North to South: 4i_0
"""
laneWE = 0
laneEW = 0
laneSN = 0
laneNS = 0
#phaseTimer # = 0 # Counts how many time steps have occured since the last phase change
while traci.simulation.getMinExpectedNumber() > 0:
traci.simulationStep()
step += 1
timeCount += 1
# Functions from http://sumo.dlr.de/daily/pydoc/traci.html
state = basics.TrafficState(traci)
#newPhase = learningAgents.chooseActionReflex(state, 0)
#traci.trafficlights.setPhase("0", newPhase)
if step >= 32:
step = 0
print "Stepped"
if evaluator.switchPhase(state, timeCount, 0):
# we are not already switching
#if traci.inductionloop.getLastStepVehicleNumber("0") > 0:
if traci.trafficlights.getPhase("0") == 2:
# there is a vehicle from the north, switch
traci.trafficlights.setPhase("0", 3)
else:
# otherwise try to keep green for EW
traci.trafficlights.setPhase("0", 2)
time = util.getTime(timeCount)
if time[1] == 7 and time[2] == 0 and time[3] == 0:
rushHour = 1
if time[1] >= 7 and time[1] < 9:
laneWE = ((laneWE * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('1i_0')) / rushHour
laneEW = ((laneEW * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('2i_0')) / rushHour
laneSN = ((laneSN * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('3i_0')) / rushHour
laneNS = ((laneNS * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('4i_0')) / rushHour
if time[1] == 9 and time[2] == 0 and time[3] == 0:
outFile.write(
str(
util.stringWaitTimes(timeCount, laneWE, laneEW, laneSN,
laneNS)))
outFile.write('\n')
laneWE = 0
laneEW = 0
laneSN = 0
laneNS = 0
if time[1] == 17 and time[2] == 0 and time[3] == 0:
rushHour = 1
if time[1] >= 17 and time[1] < 19:
laneWE = ((laneWE * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('1i_0')) / rushHour
laneEW = ((laneEW * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('2i_0')) / rushHour
laneSN = ((laneSN * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('3i_0')) / rushHour
laneNS = ((laneNS * (rushHour - 1)) +
traci.lane.getLastStepMeanSpeed('4i_0')) / rushHour
if time[1] == 19 and time[2] == 0 and time[3] == 0:
outFile.write(
str(
util.stringWaitTimes(timeCount, laneWE, laneEW, laneSN,
laneNS)))
outFile.write('\n')
laneWE = 0
laneEW = 0
laneSN = 0
laneNS = 0
"""
#getting a wait time string
if timeCount%60 == 0:
#print util.getTime(timeCount)
#print laneWE
#print laneEW
#print laneSN
#print laneNS
#outFile.write(util.stringWaitTimes(timeCount, laneWE, laneEW, laneSN, laneNS))
"""
"""
if traci.trafficlights.getPhase("0") == 2:
# we are not already switching
#if traci.inductionloop.getLastStepVehicleNumber("0") > 0:
if learningAgents.switchPhaseReflex(state, 0):
# there is a vehicle from the north, switch
traci.trafficlights.setPhase("0", 3)
else:
# otherwise try to keep green for EW
traci.trafficlights.setPhase("0", 2)
"""
rushHour += 1
step += 1
outFile.close()
traci.close()
sys.stdout.flush()
def generate_routefile():
random.seed(42) # make tests reproducible
#N = 86400 #One Day
#N = 172800 #Two Days
N = 691200 #Eight Days
# number of time steps, one tick is one second.
#break points will be set at rush hour, end of day 1, start of day 8, rush hour day
trafficBase = .08
# demand per second from different directions
pWE = trafficBase #travel from a suburb into a city
pEW = trafficBase #travel from a city into a suburb
pNS = trafficBase * .7 #Uniform NS traffic the entire time
pSN = trafficBase * .7 #Uniform SN traffic the entire time
time = 0
with open("data/cross.rou.xml", "w") as routes:
print >> routes, """<routes>
<vType id="typeWE" accel="0.8" decel="4.5" sigma="0.5" length="5" minGap="2.5" maxSpeed="16.67" guiShape="passenger"/>
<vType id="typeNS" accel="0.8" decel="4.5" sigma="0.5" length="5" minGap="2.5" maxSpeed="16.67" guiShape="passenger"/>
<route id="right" edges="51o 1i 2o 52i" />
<route id="left" edges="52o 2i 1o 51i" />
<route id="down" edges="54o 4i 3o 53i" />
<route id="up" edges="53o 3i 4o 54i" />"""
lastVeh = 0
vehNr = 0
for i in range(N):
if random.uniform(0, 1) < pWE:
print >> routes, ' <vehicle id="right_%i" type="typeWE" route="right" depart="%i" />' % (
vehNr, i)
vehNr += 1
lastVeh = i
if random.uniform(0, 1) < pEW:
print >> routes, ' <vehicle id="left_%i" type="typeWE" route="left" depart="%i" />' % (
vehNr, i)
vehNr += 1
lastVeh = i
if random.uniform(0, 1) < pNS:
print >> routes, ' <vehicle id="down_%i" type="typeNS" route="down" depart="%i" />' % (
vehNr, i)
vehNr += 1
lastVeh = i
if random.uniform(0, 1) < pSN:
print >> routes, ' <vehicle id="up_%i" type="typeNS" route="up" depart="%i" />' % (
vehNr, i)
vehNr += 1
lastVeh = i
time = util.getTime(i)
#Morning rush hour defined as starting around 7am and continuing until 9am, peaking at 8am, gradual increase and decrease.
#Set to alter the value every minute
if time[1] < 9 & time[1] > 7 & time[3] == 0:
if time[1] < 8:
pWE += .005
else:
pWE -= .005
#Afternoon rush hour defined as starting at 5pm and going until 7pm, sharp increase with slow taper.
#Set to alter the value every minute
if time[1] > 17 & time[1] < 19 & time[3] == 0:
if time[1] == 5 & time[2] < 15:
pEW += .02
else:
pEW -= .00125
#Resetting the traffic values to prevent weird things happening with floats.
if time[1] == 0 & time[2] == 0 & time[3] == 0:
pWE = trafficBase
pEW = trafficBase
#leave north to south / south to north traffic constant for the whole experiment.
print >> routes, "</routes>"
def prepare(self, features_k_nearest_neighbors, nonzero_indices = None, all_save_load = False, regenerate_neightborhood_indices = False):
#print np.shape(self.processor.pts3d_bound), 'shape pts3d_bound'
imgTmp = cv.cvCloneImage(self.processor.img)
self.imNP = ut.cv2np(imgTmp,format='BGR')
###self.processor.map2d = np.asarray(self.processor.camPts_bound) #copied from laser to image mapping
if features_k_nearest_neighbors == None or features_k_nearest_neighbors == False: #use range
self.kdtree2d = kdtree.KDTree(self.processor.pts3d_bound.T)
#print len(nonzero_indices)
#print np.shape(np.asarray((self.processor.pts3d_bound.T)[nonzero_indices]))
if nonzero_indices != None:
print ut.getTime(), 'query ball tree for ', len(nonzero_indices), 'points'
kdtree_query = kdtree.KDTree((self.processor.pts3d_bound.T)[nonzero_indices])
else:
print ut.getTime(), 'query ball tree'
kdtree_query = kdtree.KDTree(self.processor.pts3d_bound.T)
filename = self.processor.config.path+'/data/'+self.processor.scan_dataset.id+'_sphere_neighborhood_indices_'+str(self.processor.feature_radius)+'.pkl'
if all_save_load == True and os.path.exists(filename) and regenerate_neightborhood_indices == False:
#if its already there, load it:
print ut.getTime(), 'loading',filename
self.kdtree_queried_indices = ut.load_pickle(filename)
else:
self.kdtree_queried_indices = kdtree_query.query_ball_tree(self.kdtree2d, self.processor.feature_radius, 2.0, 0.2) #approximate
print ut.getTime(), 'queried kdtree: ',len(self.kdtree_queried_indices),'points, radius:',self.processor.feature_radius
if all_save_load == True:
ut.save_pickle(self.kdtree_queried_indices, filename)
#make dict out of list for faster operations? (doesn't seem to change speed significantly):
#self.kdtree_queried_indices = dict(zip(xrange(len(self.kdtree_queried_indices)), self.kdtree_queried_indices))
else: #experiemental: use_20_nearest_neighbors == True
#TODO: exclude invalid values in get_featurevector (uncomment code there)
self.kdtree2d = kdtree.KDTree(self.processor.pts3d_bound.T)
self.kdtree_queried_indices = []
print ut.getTime(), 'kdtree single queries for kNN start, k=', features_k_nearest_neighbors
count = 0
for point in ((self.processor.pts3d_bound.T)[nonzero_indices]):
count = count + 1
result = self.kdtree2d.query(point, features_k_nearest_neighbors,0.2,2,self.processor.feature_radius)
#existing = result[0][0] != np.Inf
#print existing
#print result[1]
self.kdtree_queried_indices += [result[1]] #[existing]
if count % 4096 == 0:
print ut.getTime(),count
print ut.getTime(), 'kdtree singe queries end'
#convert to numpy array -> faster access
self.kdtree_queried_indices = np.asarray(self.kdtree_queried_indices)
#print self.kdtree_queried_indices
#takes long to compute:
#avg_len = 0
#minlen = 999999
#maxlen = 0
#for x in self.kdtree_queried_indices:
# avg_len += len(x)
# minlen = min(minlen, len(x))
# maxlen = max(maxlen, len(x))
#avg_len = avg_len / len(self.kdtree_queried_indices)
#print ut.getTime(), "range neighbors: avg_len", avg_len, 'minlen', minlen, 'maxlen', maxlen
#create HSV numpy images:
# compute the hsv version of the image
image_size = cv.cvGetSize(self.processor.img)
img_h = cv.cvCreateImage (image_size, 8, 1)
img_s = cv.cvCreateImage (image_size, 8, 1)
img_v = cv.cvCreateImage (image_size, 8, 1)
img_hsv = cv.cvCreateImage (image_size, 8, 3)
cv.cvCvtColor (self.processor.img, img_hsv, cv.CV_BGR2HSV)
cv.cvSplit (img_hsv, img_h, img_s, img_v, None)
self.imNP_h = ut.cv2np(img_h)
self.imNP_s = ut.cv2np(img_s)
self.imNP_v = ut.cv2np(img_v)
textures = texture_features.eigen_texture(self.processor.img)
self.imNP_tex1 = textures[:,:,0]
self.imNP_tex2 = textures[:,:,1]
self.debug_before_first_featurevector = True
self.generate_voi_histogram(self.processor.point_of_interest,self.processor.voi_width)
def exit(self): print "[%s][%s] Client shutting down!" % (getTime(), self.client_name) sys.exit()
