def prepare_training_data():
word_ranks = get_word_ranks()
corpus = get_corpus()
segmenter = Segmenter()
with codecs.open('./data/training.txt', 'w', 'utf-8') as fout:
for poem in corpus:
poem['keyword'] = []
stop=False
for sentence in poem['sentence']:
segs = list(filter(lambda seg: seg in word_ranks, segmenter.segment(sentence)))
if len(segs) == 0:
stop = True
break
if len(poem['sentence'])!=4 or stop:
continue
for sentence in poem['sentence']:
segs = list(filter(lambda seg: seg in word_ranks, segmenter.segment(sentence)))
if len(segs) == 0:
print('aaa', sentence)
keyword = reduce(lambda x,y: x if word_ranks[x]>word_ranks[y] else y, segs)
poem['keyword'].append(keyword)
if(len(keyword)>=2):
print(sentence, keyword)
fout.write(sentence + '\t' + keyword + '\n')
def fetch_labeled_data():
str_old_time = "2015-08-01 00:00:00"
str_new_time = "2016-11-31 00:00:00"
proj_name = "article_cat"
LabeledCrawler(proj_name=proj_name).rebuild_table()
LabeledCrawlerIheima(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawlerKanchai(proj_name=proj_name).crawl(str_old_time,
str_new_time)
LabeledCrawlerLeiphone(proj_name=proj_name).crawl(str_old_time,
str_new_time)
LabeledCrawlerLieyun(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawlerSootoo(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawlerYiou(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawler7tin(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerAilab(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerBaidu(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerSinaVR(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerVarkr(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
seg = Segmenter(proj_name=proj_name)
seg.seg(skip_exist=True)
seg.join_segfile()
def fetch_nonlabeled_data():
proj_name = "article150801160830"
str_old_time = "2015-08-01 00:00:00"
str_new_time = "2016-12-31 00:00:00"
# Crawler(proj_name=proj_name).rebuild_table()
# Crawler163(proj_name=proj_name).crawl(str_old_time, str_new_time)
# Crawler36Kr(proj_name=proj_name).crawl(str_old_time, str_new_time)
# CrawlerGeekPark(proj_name=proj_name).crawl(str_old_time, str_new_time)
# CrawlerLeiphone(proj_name=proj_name).crawl(str_old_time, str_new_time)
# CrawlerKanchai(proj_name=proj_name).crawl(str_old_time, str_new_time)
# CrawlerHuxiu(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawlerIheima(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawlerKanchai(proj_name=proj_name).crawl(str_old_time,
str_new_time)
LabeledCrawlerLeiphone(proj_name=proj_name).crawl(str_old_time,
str_new_time)
LabeledCrawlerLieyun(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawlerSootoo(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawlerYiou(proj_name=proj_name).crawl(str_old_time, str_new_time)
LabeledCrawler7tin(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerAilab(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerBaidu(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerSinaVR(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
LabeledCrawlerVarkr(proj_name=proj_name).crawl("2000-08-01 00:00:00",
str_new_time)
seg = Segmenter(proj_name=proj_name)
seg.seg(skip_exist=True)
seg.join_segfile()
def get_text_ranks():
segmenter = Segmenter()
stopwords = get_stopwords()
print("Start TextRank over the selected quatrains ...")
corpus = get_corpus()
adjlist = dict()
for idx, poem in enumerate(corpus):
if 0 == (idx + 1) % 10000:
print("[TextRank] Scanning %d/%d poems ..." %
(idx + 1, len(corpus)))
for sentence in poem['sentence']:
segs = list(
filter(lambda word: word not in stopwords,
segmenter.segment(sentence)))
for seg in segs:
if seg not in adjlist:
adjlist[seg] = dict()
for i, seg in enumerate(segs):
for _, other in enumerate(segs[i + 1:]):
if seg != other:
adjlist[seg][other] = adjlist[seg][other] + 1 \
if other in adjlist[seg] else 1.0
adjlist[other][seg] = adjlist[other][seg] + 1 \
if seg in adjlist[other] else 1.0
for word in adjlist:
w_sum = sum(weight for other, weight in adjlist[word].items())
for other in adjlist[word]:
adjlist[word][other] /= w_sum
print("[TextRank] Weighted graph has been built.")
_text_rank(adjlist)
def applySegmentation(metafilename,img,device='/gpu:0',conf=None):
'''
Loads the graph from the meta file `metafilename' and predicts segmentations for the image stack `img'. The graph is
expected to have a collection "endpoints" storing the x,y_,y,ypred list of tensors where x is the input and ypred the
predicted segmentation. The first 2 dimensions of `img' must be the XY dimensions, other dimensions are flattened out.
The values of `img' are also expected to be normalized. Returns a stack of binary masks with the same shape as `img'.
'''
seg=Segmenter(metafilename,device,conf)
origshape=tuple(img.shape)
tf.logging.info('Input dimensions: %r'%(origshape,))
shape=origshape+(1,1,1) # add extra dimensions to the shape to make a 4D shape
shape=shape[:5] # clip extra dimensions off so that this is a 5D shape description
width,height,slices,timesteps,depth=shape
img=img.astype(np.dtype('<f8')).reshape(shape) # convert input into a 5D image of shape XYZTC
img=rescaleArray(img)
for s in range(slices):
tf.logging.info('Segmenting slice %s'%s)
for t in range(timesteps):
st=img[...,s,t,:]
if st.max()>st.min(): # segment if the image is not blank
pred=seg.apply(st)
img[...,s,t,:]=0
img[...,s,t,0]=pred
return img.reshape(origshape)
def __init__(self, tagger_pickle = None):
if tagger_pickle == None:
path = os.path.abspath(__file__)\
.replace(os.path.basename(__file__), '')
tagger_pickle = \
'%smodels/sinica_treebank_brill_aubt.pickle' % (path)
self.tagger = pickle.load(open(tagger_pickle))
self.segmenter = Segmenter()
def __init__(self, app, config=None):
self.app = app
ngrams_file = config.get('segmenter', 'ngrams_file')
self.app.log.debug(f'Trying to load ngrams file {ngrams_file}')
try:
with open(ngrams_file, 'r') as nf:
ngrams = json.load(nf)
self.app.log.debug(f'Loaded ngrams file {ngrams_file}.')
except FileNotFoundError as err:
self.app.log.info(
f'Ngrams file {ngrams_file} not found. Using default configuration.'
)
self._ws = Segmenter(ngrams)
def main():
img_size = 505
gpu_id, net_path, model_path, img_paths = process_arguments(sys.argv)
palette = pascal_palette_invert()
net = Segmenter(net_path, model_path, gpu_id)
for img_path in img_paths:
img, cur_h, cur_w = preprocess_image(img_path, img_size)
segm_result = net.predict([img])
segm_post = postprocess_segmentation(segm_result, cur_h, cur_w,
palette)
concatenate = True
segm_name = os.path.basename(img_path).split('.')[0] + '-label.png'
save_result(segm_post, segm_name, concatenate, img_path)
def load_segmenter(self):
training_file_name = os.path.splitext(
self.settings['training_file'])[0]
outpath = training_file_name + '.segmenter.pickle'
segmenter = None
if os.path.exists(outpath):
with open(outpath, 'rb') as handle:
segmenter = pickle.load(handle)
else:
if outpath is not None:
segmenter = Segmenter(self.settings['training_file'])
with open(outpath, 'wb') as f:
pickle.dump(segmenter, f)
print("Segmenter model written out to {}".format(outpath))
return segmenter
def run(self):
base_preprocessor = Preprocessor(self.basefile)
base_preprocessed_image_stack = base_preprocessor.preprocess_basefile()
arc_preprocessor = Preprocessor(self.arcfile)
arc_preprocessed_image_stack = arc_preprocessor.preprocess_arcfile()
x, y, z = self.cell_aggragation_shape
segmenter = Segmenter(base_preprocessed_image_stack,
self.create_np_ellipsoid(x, y, z),
"WS",
generate_debugging=self.enable_debugging)
segmented_image_stack = segmenter.run_segmentation()
analysis = Analysis(segmented_image_stack,
arc_preprocessed_image_stack)
analysis.generate_report()
colorized_image_stack = analysis.colorize_overlapping_cells()
self.save_image_stack(colorized_image_stack)
def __init__(self, model_file):
self.max_success_count = 0
self.success_count = 0
self.dropbox_dict = {}
self.dict_list = []
self.object_list = None
self.color_list = []
self.yaml_saved = False
self.collision_map_complete = False
self.goal_positions = [0] #[0, -1.0, 1.0] uncomment to rotate robot
self.table_cloud = None
self.collision_map_base_list = []
self.detected_objects = None
#load SVM object classifier
self.model = pickle.load(open(model_file, 'rb'))
#initialize object segmenter
self.segmenter = Segmenter(self.model)
#initialize point cloud publishers
self.objects_pub = rospy.Publisher("/pcl_objects",
PointCloud2,
queue_size=1)
#self.table_pub = rospy.Publisher("/pcl_table", PointCloud2, queue_size=1)
#self.colorized_cluster_pub = rospy.Publisher("/colorized_clusters", PointCloud2, queue_size=1)
self.object_markers_pub = rospy.Publisher("/object_markers",
Marker,
queue_size=1)
self.detected_objects_pub = rospy.Publisher("/detected_objects",
DetectedObjectsArray,
queue_size=1)
self.denoised_pub = rospy.Publisher("/denoised_cloud",
PointCloud2,
queue_size=1)
#self.reduced_cloud_pub = rospy.Publisher("/decimated_cloud", PointCloud2, queue_size = 1)
self.collision_cloud_pub = rospy.Publisher("/pr2/3d_map/points",
PointCloud2,
queue_size=1)
print('PR2 object initialized.')
def segment(self, image, slow=False):
def predictor(X):
X = np.expand_dims(X, axis=0)
y = self.predict(X)
y = np.squeeze(y, axis=0)
return y
if slow:
input_height = self.S.image_height
input_width = self.S.image_width
else:
_, input_height, input_width = image.shape
segmenter = Segmenter(predictor,
self.S.image_depth,
input_height,
input_width,
image)
return segmenter.predict()
def main(input_path, output_path):
imgs_path = sorted(glob(f'{input_path}/*'))
for img_path in imgs_path:
img_name = img_path.split('/')[-1].split('.')[0]
out_file = open(f'{output_path}/{img_name}.txt', "w")
print(f"Processing new image {img_name}...")
img = io.imread(img_path)
img = gray_img(img)
horizontal = IsHorizontal(img)
if horizontal == False:
theta = deskew(img)
img = rotation(img, theta)
img = get_gray(img)
img = get_thresholded(img, threshold_otsu(img))
img = get_closer(img)
horizontal = IsHorizontal(img)
original = img.copy()
gray = get_gray(img)
bin_img = get_thresholded(gray, threshold_otsu(gray))
segmenter = Segmenter(bin_img)
imgs_with_staff = segmenter.regions_with_staff
most_common = segmenter.most_common
# imgs_without_staff = segmenter.regions_without_staff
imgs_spacing = []
imgs_rows = []
coord_imgs = []
for i, img in enumerate(imgs_with_staff):
spacing, rows, no_staff_img = coordinator(img, horizontal)
imgs_rows.append(rows)
imgs_spacing.append(spacing)
coord_imgs.append(no_staff_img)
print("Recognize...")
recognize(out_file, most_common, coord_imgs,
imgs_with_staff, imgs_spacing, imgs_rows)
out_file.close()
print("Done...")
def main():
# default fpaths
ngrams1 = "1grams.txt"
ngrams2 = "2grams.txt"
# parse arguments
args = sys.argv[1:]
for arg in args:
if arg == "-simple":
ngrams2 = None
# check existence of 1grams
if not os.path.isfile("1grams.txt"):
print("Error: could not find 1grams.txt.")
print("Exiting....")
sys.exit(1)
# check existence of 2grams and 3grams
if ngrams2 and not os.path.isfile(ngrams2):
print("Could not find some files.")
print("Segmenter will run without use of 2grams and 3grams.")
ngrams2 = None
# make segmenter
global __seg
__seg = Segmenter(ngrams1, fpath_2grams=ngrams2)
# show intro msg
clear()
global __INTRO
print(__INTRO)
print("hello, world!")
# read, eval
while (True):
user_input = str(input("> "))
eval(user_input)
def test_net(net_path, model_path, images, labels, lut, gpu_id):
net = Segmenter(net_path, model_path, gpu_id)
mean_vec = np.array([103.939, 116.779, 123.68], dtype=np.float32)
reshaped_mean_vec = mean_vec.reshape(1, 1, 3);
pa_list = []
ma_list = []
m_IU_list = []
fw_IU_list = []
pb = ProgressBar(len(images))
for img_path, label_path in zip(images, labels):
im, cur_h, cur_w = preprocess_image(img_path, reshaped_mean_vec)
label = imread(label_path)
label = lut[label]
segmentation = net.predict([im])
pred = segmentation[0:cur_h, 0:cur_w]
pa = pixel_accuracy(pred, label)
ma = mean_accuracy(pred, label)
m_IU = mean_IU(pred, label)
fw_IU = frequency_weighted_IU(pred, label)
pa_list.append(pa)
ma_list.append(ma)
m_IU_list.append(m_IU)
fw_IU_list.append(fw_IU)
pb.print_progress()
print("pixel_accuracy: " + str(np.mean(pa_list)))
print("mean_accuracy: " + str(np.mean(ma_list)))
print("mean_IU: " + str(np.mean(m_IU_list)))
print("frequency_weighted: " + str(np.mean(fw_IU_list)))
def __init__(self, config, nodeName, loadFromFile=False):
self.node = config.GetChild(nodeName)
self.segmenter = Segmenter(config, "__segmenter__")
self.trained = loadFromFile
PyMining.Init(config, "__global__", loadFromFile)
def main():
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--draw-markers", action="store_true", default=False,
help="")
ap.add_argument("-c", "--draw-confidence", action="store_true", default=False,
help="")
ap.add_argument("-t", "--confidence-threshold", type=float, default=0.9,
help="")
ap.add_argument("-p", "--draw-pose", action="store_false", default=True,
help="")
ap.add_argument("-u", "--draw-unstable", action="store_true", default=False,
help="")
ap.add_argument("-s", "--draw-segmented", action="store_true", default=False,
help="")
args = vars(ap.parse_args())
confidence_threshold = args["confidence_threshold"]
"""MAIN"""
# Video source from webcam or video file.
video_src = 0
cam = cv2.VideoCapture(video_src)
_, sample_frame = cam.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
if isWindows():
thread = threading.Thread(target=get_face, args=(mark_detector, confidence_threshold, img_queue, box_queue))
thread.daemon = True
thread.start()
else:
box_process = Process(target=get_face,
args=(mark_detector, confidence_threshold, img_queue, box_queue))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cam.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
if video_src == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
result = box_queue.get()
if result is not None:
if args["draw_confidence"]:
mark_detector.face_detector.draw_result(frame, result)
# unpack result
facebox, confidence = result
# fix facebox if needed
if facebox[1] > facebox[3]:
facebox[1] = 0
if facebox[0] > facebox[2]:
facebox[0] = 0
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]: facebox[3],
facebox[0]: facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
marks = mark_detector.detect_marks(face_img)
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# segment the image based on markers and facebox
seg = Segmenter(facebox, marks, frame.shape[1], frame.shape[0])
if args["draw_segmented"]:
mark_detector.draw_box(frame, seg.getSegmentBBs())
cv2.imshow("fg", seg.getSegmentJSON()["faceGrid"])
if args["draw_markers"]:
mark_detector.draw_marks(
frame, marks, color=(0, 255, 0))
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
stable_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
stable_pose.append(ps_stb.state[0])
stable_pose = np.reshape(stable_pose, (-1, 3))
if args["draw_unstable"]:
pose_estimator.draw_annotation_box(
frame, pose[0], pose[1], color=(255, 128, 128))
if args["draw_pose"]:
pose_estimator.draw_annotation_box(
frame, stable_pose[0], stable_pose[1], color=(128, 255, 128))
# Show preview.
cv2.imshow("Preview", frame)
if cv2.waitKey(10) == 27:
break
# Clean up the multiprocessing process.
if not isWindows():
box_process.terminate()
box_process.join()
def thread_func(args, detector, predictor, img_queue, result_queue):
"""Get face from image queue. This function is used for multiprocessing"""
# Introduce mark_detector to detect landmarks.
gaze_model = args["gaze_net"]
eye_size = args["eye_size"]
face_size = args["face_size"]
inputs = args["inputs"]
outputs = args["outputs"]
print("[INFO] loading gaze predictor...")
gaze_detector = GazeEstimator(gaze_model=gaze_model,
eye_image_size=eye_size,
face_image_size=face_size,
inputs=inputs,
outputs=outputs)
# init variables
detectorWidth = 400
faceBoxScale = 0.15
while True:
# get the image
try:
frame = img_queue.get(timeout=1)
except Q.Empty:
print("Image Q empty, thread exiting!")
return
# update factors
originalWidth = frame.shape[1]
factor = originalWidth / detectorWidth
# resize for face detection
image = imutils.resize(frame, width=detectorWidth)
# convert to grayscale for face detection
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# actually run face detection
faceboxes, scores, idx = detector.run(image, 0)
if faceboxes is not None and len(faceboxes) > 0:
facebox = faceboxes[0]
confidence = scores[0]
# get 5 landmarks
marks = predictor(gray, facebox)
# convert marks to np array
marks = face_utils.shape_to_np(marks)
leftEyeMarks = []
rightEyeMarks = []
# pull out left and right eye marks
for (i, (x, y)) in enumerate(marks):
[x, y] = [int(x * factor), int(y * factor)]
if i == 0 or i == 1:
leftEyeMarks.append([x, y])
if i == 2 or i == 3:
rightEyeMarks.append([x, y])
# convert the facebox from dlib format to regular BB and
# rescale it back to original image size
facebox = utils.dlib_to_box(facebox, factor, faceBoxScale)
# segment the image based on markers and facebox
seg = Segmenter(facebox, leftEyeMarks, rightEyeMarks,
frame.shape[1], frame.shape[0])
segments = seg.getSegmentJSON()
# detect gaze
gaze = gaze_detector.detect_gaze(frame, segments["leftEye"],
segments["rightEye"],
segments["face"],
segments["faceGrid"])
# pack result
result = [gaze, frame]
result_queue.put(result)
else:
result_queue.put(None)
"cache_dir", "../../models"))
model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h",
cache_dir=os.getenv(
"cache_dir", "../../models"))
audio_ds = [
os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data',
'sample.mp3'),
os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data',
'long_sample.mp3')
]
# create speech segmenter
seg = Segmenter(model_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'speech_segmenter_models'),
vad_engine='smn',
detect_gender=True,
ffmpeg='ffmpeg',
batch_size=32)
# it holds audio segmentations
segmentations = []
for audio in audio_ds:
# [('noEnergy', 0.0, 0.8), ('male', 0.8, 9.84), ('music', 9.84, 10.96), ('male', 10.96, 14.98)]
# segmentation = seg(audio, start_sec=0, stop_sec=30)
s = seg(audio)
res = {}
res['segmentation'] = s
res['audio'] = audio
segmentations.append(res)
from neuralNetworkTester import NeuralNetworkTester
from remover import Remover
import subprocess
import config
import utils
from datetime import datetime
from logger import Logger
input_file = open(config.CATEGORY_LIST, "r")
categories = input_file.read().splitlines()
input_file.close()
generator = LinkGen()
generator.run(categories)
downloader = Downloader(categories, config.BATCH_SIZE)
segmenter = Segmenter()
remover = Remover()
logger = Logger()
processed_video_count = utils.get_processed_video_count()
while processed_video_count < config.NUMBER_OF_LINKS:
processed_video_count = utils.get_processed_video_count()
load = utils.get_checkpoints_flag()
downloader.run()
segmenter.run()
source = config.NEURAL_NETWORK_PATH
tfrecords_command = 'python2.7 %s/utils/generate_tfrecords_dataset.py' \
import glob
from PIL import Image
from segmenter import Segmenter
image_paths = glob.glob("input/*.png") # get all images in the input folder
segmenter = Segmenter() # create an instance of the classifier
predictions = segmenter.run_images(
image_paths) # run the classifier to get predictions
segmenter.save_predictions(predictions,
image_paths) # save the results to output folder
Image.fromarray(
predictions[0]).show() # show a single prediction (the first image)
#! python3
#! PY_PYTHON=3
import sys, os
from segmenter import Segmenter
if __name__ == "__main__":
seg = Segmenter(sys.argv)
def optimize(avg_speed=130, length=1055):
jams = Jam_Simulator()
segmenter = Segmenter()
segmenter = segmenter.get_segmented_route(
length, jams.generate_traffic_jams(route_length=length))
predictor = Predictor()
print(segmenter)
jams = []
for segment in segmenter:
if not segment.jam_info == None:
jam = segment.jam_info
jam.number = segment.number
jams.append(jam)
jam.end = round(
predictor.predict(
np.array([
jam.length, jam.avg_speed, jam.reason, jam.start_time
]).reshape((1, 4)))[0][0], 2)
print(segment.number)
print("******")
for jam in reversed(jams):
strecke = segmenter[jam.number].start
avg_speed = min(avg_speed, round(strecke / jam.end, 2))
if avg_speed < 40:
stri = str("roads are bad. stay at home.")
f = open("../templates/tmp.txt", "w")
f.write(stri)
f.close()
return "roads are bad. stay at home."
for i in range(jam.number):
(segmenter[i]).avg_speed = avg_speed
time = 0
benzin = 0
strom = 0
stri = str()
stri += "length, speed\n"
for segment in segmenter:
print(segment.number)
print(round(segment.length, 2))
print()
stri += "[" + str(round(segment.length, 2)) + ", " + str(
round(segment.avg_speed, 2)) + "]\n"
time += segment.length / segment.avg_speed
benzin += (3.4 + 0.00966667 * segment.avg_speed - 0.00024 * (segment.avg_speed**2) \
+ 2.53333*(10**(-6))*(segment.avg_speed**3)) * (segment.length * 0.01)
strom += (-1.1 + 0.06 * segment.avg_speed - 0.00025 *
(segment.avg_speed**2)) * (segment.length * 0.01)
print("time:")
print(round(time, 2))
print("benzin")
print(round(benzin, 2))
print("strom")
print(round(strom, 2))
stri += "Time: " + str(round(time, 2)) + "\n"
stri += "Benzin: " + str(round(benzin, 2)) + "\n"
stri += "Strom: " + str(round(strom, 2)) + "\n"
f = open("../templates/tmp.txt", "w")
f.write(stri)
f.close()