def createSegments(df, arena, segment_length, overlap):
#generates a list of segments with features for a part of dataset
iSegment = 0
logging.info("Segment: " + str(iSegment))
cum_dist_end_prev = df.iloc[0]['CumulativeDistance']
temp_segment = sg.Segment(traj=df,
lseg=segment_length,
ovlp=0,
cum_dist_end_prev=cum_dist_end_prev,
arena=arena)
list_segments = [temp_segment]
while True:
iSegment = iSegment + 1
# if iSegment == 1000:
# pdb.set_trace()
logging.info("Segment: " + str(iSegment))
temp_segment = sg.Segment(
traj=df,
lseg=segment_length,
ovlp=overlap,
cum_dist_end_prev=temp_segment.last_value_segment,
arena=arena)
if temp_segment.segment_data.shape[0] > 2:
list_segments.append(temp_segment)
if temp_segment.end_of_trajectory:
break
return (list_segments)
def determine_segments(self):
columns = []
for i in range(0, len(self.bits)):
if self.bits[i] == 0:
columns.append(i)
if i == len(self.bits) - 1:
self.segments.append(s.Segment(columns.copy()))
elif self.bits[i] == 1 and len(columns) > 0:
self.segments.append(s.Segment(columns.copy()))
del columns[:]
def test_locationDensity(self):
df = preprocess.execute(
"../../Data/TestData/bee-data_NT_test_locationDensity.csv")
#(traj, lseg, ovlp, cum_dist_end_prev)
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 7, 0, 0)
length_first_segment = cs.getSegmentLength(dt_first_segment)
features_first_segment = sg.Segment(dt_first_segment,
length_first_segment, arena, 0)
feat = features_first_segment.getFeature(
enums.eFeature.LocationDensity)
SumDistanceBetweenEachPairPoints = 1 + math.sqrt(1**2 + 2**2) + 2 \
+ 2 + math.sqrt(1**2 + 2**2) \
+ 1
nCr = 6
LocationDensity_TrueValue = SumDistanceBetweenEachPairPoints / nCr
self.assertEqual(feat.value, LocationDensity_TrueValue)
def parse(self, location):
with open(location, 'r') as f:
content = f.read()
pattern = r"^#EXT-X-TARGETDURATION:(?P<target_duration>\d+)$"
match = re.search(pattern, content, re.M)
if match is None:
raise RuntimeError("Unable to find target duration")
target_duration = int(match.group("target_duration"))
path = os.path.dirname(location)
segments = []
segment_index = 0
segment_start_time = 0
# Regex parsing, output will be iteration object with "duration" and "location"
# for each segment
pattern = r"^#EXTINF:(?P<duration>\d+\.\d*|\d+),[^ ](?P<location>.*?\.(ts|aac))$"
for match in re.finditer(pattern, content, re.M):
segment_duration = float(match.group("duration"))
segment_location = os.path.join(path, match.group("location"))
# Validate that file exists at location
if not os.path.isfile(segment_location):
raise FileNotFoundError("Unable to find {}".format(location))
s = segment.Segment(segment_index, segment_location,
segment_start_time, segment_duration)
segments.append(s)
segment_index += 1
segment_start_time += segment_duration
# Let's set discontinuity flag on last segment
last_segment = segments[segment_index - 1]
last_segment.update_discontinuity(True)
return (target_duration, segments)
def test_calcCentralDisplacement_withinCorrectRange(self):
df = preprocess.execute("../../Data/TestData/bee-data_NT_test.csv")
arena = classArena.classArena(df)
dt_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0, 0)
for i in range(0, 20):
dt_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0.3, cum_dist_end_segment)
length_segment = cs.getSegmentLength(dt_segment)
features_segment = sg.Segment(dt_segment, length_segment, arena, 0)
cent_displ = features_segment.getFeature(
enums.eFeature.CentralDisplacement).value
# print("cent_displ:", cent_displ)
self.assertLessEqual(cent_displ,
1) # test never bigger than arena size
self.assertGreater(cent_displ, 0) # test positive
self.assertGreaterEqual(
cent_displ,
(features_segment.ellipse.centre[0] - arena.centre_x) * 2 /
arena.diameter) # test greater than ellipse centre x
self.assertGreaterEqual(
cent_displ,
(features_segment.ellipse.centre[1] - arena.centre_y) * 2 /
arena.diameter) # test greater than ellipse centre y
def game_logic(self):
# save a copy of the tail of the snake in case it grows
snake_tail = self.__snake.get_tail()
snake_tail_copy = segment.Segment(snake_tail.get_x(),
snake_tail.get_y(),
snake_tail.get_dir())
# update the snake
self.__snake.move_all()
self.__snake.update_dirs()
if self.__snake.collides() or self.__snake.out_of_bounds():
glo.DIE_SOUND.play()
return True
# advance movement queue
new_head_dir = self.__movement_queue.pop()
if new_head_dir is not None:
self.__snake.change_dir(new_head_dir)
snake_head = self.__snake.get_head()
# check if the snake has run into food
if snake_head.get_x() == self.__food.get_x() and \
snake_head.get_y() == self.__food.get_y():
self.__growth_queue += glo.SNAKE_GROWTH_RATE
self.__food.new_pos(self.__snake)
glo.EAT_SOUND.play()
# grow the snake if the growth queue is not empty
if self.__growth_queue > 0:
self.__snake.grow(snake_tail_copy)
self.__growth_queue -= 1
return False
def split(self, node, ubSet):
epsilon = 1e-8
regions = self.discontinuousRegions()
if len(regions) == 1:
return [self]
else:
result = []
self.computeMetaData()
for r in regions:
points = set()
metaDataForPoint = {}
for s in self.segments:
if s.p1[0] <= r[0] + epsilon and s.p1[1] <= r[1] + epsilon:
points.add(s.p1)
metaDataForPoint[s.p1] = self.metaDataForPoint[s.p1]
if s.p2[0] <= r[0] + epsilon and s.p2[1] <= r[1] + epsilon:
points.add(s.p2)
metaDataForPoint[s.p2] = self.metaDataForPoint[s.p2]
points = sorted([p for p in points])
segments = [
segment.Segment(p1, p2, p2[0], r[1], metaDataForPoint[p1],
metaDataForPoint[p2])
for p1, p2 in zip(points[:-1], points[1:])
]
segments[-1].right = r[0]
lb = LowerBoundSet(segments)
lb.metaDataForPoint = metaDataForPoint
lb.metaData = lambda: metaDataForPoint.itervalues()
result.append(lb)
return result
def initializePlayer(self, start_x, start_y):
self.length = 4
self.segments.clear()
start_x = config.screen_width / 2
start_y = config.screen_height / 2
for i in range(self.length):
self.segments.append(
seg.Segment(start_x - config.tile_size * i, start_y))
def add_segment(self, curve, start_y=0, end_y=0):
"""Creates a new segment and pushes it to the segments array"""
palette = "dark" if (len(self.segments) /
s.RUMBLE_LENGTH) % 2 == 0 else "light"
segment = seg.Segment(self.palettes[palette], len(self.segments),
curve, start_y, end_y)
self.segments.append(segment)
def addIfMustSub(c1, c2, E, metaData):
# we can improve the value of 'right' using the fact that the
# same space is also covered by the segment right of that one
# we use C as a stack so if there is an item in C, there is an
# segment right of this one
s = segment.Segment(c1, c2, c2[0] if len(C) > 0 else self.right,
self.top, metaData[c1], metaData[c2])
if s.shouldBeConsidered():
E.append(s)
def _createSegment(attrs):
result = segment.Segment()
for attr in attrs:
value = attr[1]
if set([attr[0]]) < set(['arrival', 'departure']):
value = datetime.datetime.strptime(value, '%Y-%m-%dT%H:%M:%S')
elif set([attr[0]]) < set(['bags_allowed', 'bag_price', 'price']):
value = int(value)
setattr(result, attr[0], value)
return result
def load_data(filepath):
f = open(filepath, "rt")
data = []
for line in f:
int_list = [int(x) for x in line.split(" ")]
if len(int_list) < 2:
raise Exception("Data currupted.")
data.append(segment.Segment(int_list[0], int_list[1]))
f.close()
return data
def get_segmented_route(self, route, traffic_jams):
segments = []
current_pos = 0
number = 0
for jam in traffic_jams:
if jam.start > current_pos:
segments.append(
seg.Segment(current_pos, jam.start - current_pos, number))
number += 1
segments.append(seg.Segment(jam.start, jam.length, number, jam))
number += 1
current_pos = jam.start + jam.length
if current_pos < route:
segments.append(
seg.Segment(current_pos, route - current_pos, number))
return segments
def __init__(self, segment_grid, voice_name):
info('Read voice {}'.format(voice_name))
self.owner = segment_grid
self.voice_name = voice_name
self.status = self.owner.owner
self.project = self.owner.project
self.vcs = self.project.vcs
self._segments = {}
self._completion_data = {}
self._dir = os.path.join(self.project['paths']['music'], voice_name)
for seg in self.segment_names():
self._segments[seg] = segment.Segment(self, seg)
def test_MaximumLoopLength(self):
df = pd.read_csv("../../Data/TestData/bee-data_NT_test_maxloop.csv")
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 20, 0, 0)
length_first_segment = cs.getSegmentLength(dt_first_segment)
features_first_segment = sg.Segment(dt_first_segment,
length_first_segment,
arena,
index=0)
feat = features_first_segment.getFeature(enums.eFeature.MaximumLoop)
self.assertEqual(feat.value, 15)
def test_iQRangeDistanceCentre(self):
df = preprocess.execute("../../Data/TestData/bee-data_NT_test.csv")
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0, 0)
dt_second_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0.3, cum_dist_end_segment)
len_second_segment = cs.getSegmentLength(dt_second_segment)
second_segment_features = sg.Segment(dt_second_segment,
len_second_segment, arena, 0)
feat = second_segment_features.getFeature(enums.eFeature.IQRange)
self.assertAlmostEqual(feat.value, 0.0164803959758471)
def iterate(self):
"""Iterates applying transformations and plotting"""
for k in range(self.max):
newSegments = []
for t in self.transformations:
t.printTransformation()
for i in range(self.position, len(self.segments)):
for t in self.transformations:
ns = sg.Segment(self.segments[i],
t.apply2segment(self.segments[i]))
newSegments.append(ns)
self.segments = self.segments + newSegments
if (self.plotForEach):
pt.Plotter(self.segments)
if (not self.plotForEach):
pt.Plotter(self.segments)
def test_checkCorrectingRotation(self):
df = preprocess.execute(
"../../Data/TestData/bee-data_NT_test_maxloop.csv")
#(traj, lseg, ovlp, cum_dist_end_prev)
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 20, 0, 0)
length_first_segment = cs.getSegmentLength(dt_first_segment)
features_first_segment = sg.Segment(dt_first_segment,
length_first_segment, arena, 0)
feat = features_first_segment.getFeature(enums.eFeature.MeanSpeed)
self.assertEqual(feat.value, 118.75)
def test_sumAbsAngles(self):
df = preprocess.execute(
"../../Data/TestData/bee-data_NT_test_sum_abs_angles.csv")
#(traj, lseg, ovlp, cum_dist_end_prev)
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 7, 0, 0)
length_first_segment = cs.getSegmentLength(dt_first_segment)
features_first_segment = sg.Segment(dt_first_segment,
length_first_segment, arena, 0)
feat = features_first_segment.getFeature(
enums.eFeature.SumAbsoluteAngles)
self.assertEqual(feat.value, 2 * math.pi)
def segment_audio(y, sr, beat_indices):
""" segment_audio accepts a numpy array and returns a list of semgent objects """
segments = []
for idx in range(0, len(beat_indices) - 1):
start = beat_indices[idx]
end = beat_indices[idx + 1]
quarter = y[start:end]
if len(quarter) == 0:
continue
mfcc = dsp.to_mfcc(quarter, sr=sr)
segment = sg.Segment(start,
end,
quarter=quarter,
sr=sr,
mfcc=mfcc,
distance_to_center=None)
segments.append(segment)
return segments
def get_unions(segments):
if len(segments) == 1:
return segments[0]
segments.sort(key=lambda s: (s.x1, s.x2), reverse=True)
# сюда
partial = []
while len(segments) != 1:
seg1 = segments.pop()
seg2 = segments.pop()
if seg2 in seg1:
segments.append(seg2)
else:
if is_seg_intersection(seg1, seg2):
segments.append(segment.Segment(seg1.x1, seg2.x2))
else:
segments.append(seg2)
partial.append(seg1)
return sorted(segments + partial, key=lambda s: (s.x1, s.x2))
def test_MedianDistanceCentre(self):
df = preprocess.execute("../../Data/TestData/bee-data_NT_test.csv")
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0, 0)
dt_second_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0.3, cum_dist_end_segment)
length_second_segment = cs.getSegmentLength(dt_second_segment)
features_second_segment = sg.Segment(dt_second_segment,
length_second_segment, arena, 0)
feat = features_second_segment.getFeature(
enums.eFeature.MedianDistanceFromCentre)
self.assertAlmostEqual(feat.value, 0.8628325515)
def test_pathEfficiency(self):
df = preprocess.execute(
"../../Data/TestData/bee-data_NT_test_sum_abs_angles.csv")
#(traj, lseg, ovlp, cum_dist_end_prev)
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 20, 0, 0)
length_first_segment = cs.getSegmentLength(dt_first_segment)
features_first_segment = sg.Segment(dt_first_segment,
length_first_segment, arena, 0)
feat = features_first_segment.getFeature(enums.eFeature.PathEfficiency)
PathEfficiency_TrueValue = 1.0 / 7.0
self.assertEqual(feat.value, PathEfficiency_TrueValue)
def segment(self):
"""Given labels for each of the moves, segment the data.
Note that this function simply segments the data according to the
segment size and overlap values in segment.py.
It then labels each segment by checking which label accounts for
the majority of the segment.
"""
assert self.label is not None
segment_start = 0
segments = []
while segment_start + segment.SEGMENT_SIZE <= len(self.sensors_data):
segment_data = self.sensors_data[segment_start:segment_start +
segment.SEGMENT_SIZE]
segments.append(segment.Segment(segment_data, self.label))
segment_start += segment.SEGMENT_OFFSET
return segments
def test_areaFormula(self):
df = preprocess.execute("../../Data/TestData/bee-data_NT_test.csv")
arena = classArena.classArena(df)
dt_first_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0, 0)
dt_second_segment, cum_dist_end_segment, end_trajectory = cs.getSegment(
df, 10, 0.3, cum_dist_end_segment)
length_second_segment = cs.getSegmentLength(dt_second_segment)
features_second_segment = sg.Segment(dt_second_segment,
length_second_segment, arena, 0)
#features_second_segment.calcMinEnclosingEllipseArea
points = np.array([[-1, 0, 0, 1], [0, 1, -1, 0]]).T
ellipse = features_second_segment.findMinEnclosingEllipse(points)
min_enclosing_ellipse_area = features_second_segment.calcMinEnclosingEllipseArea(
ellipse.radii)
self.assertAlmostEqual(min_enclosing_ellipse_area, math.pi)
def parse_bam(bam, segmentID):
sys.stderr.write(time.strftime("%c") + " Busy with parsing bam file...\n")
with os.popen(opts_sambamba + ' view -t ' + str(opts_threads) + ' ' +
bam) as bam:
for line in bam:
line = line.rstrip()
columns = line.split("\t")
cigar = parse_cigar(columns[5])
if columns[0] in reads:
read = reads[columns[0]]
else:
read = r.Read(columns[0], (len(columns[9]) + sum(cigar['H'])))
reads[columns[0]] = read
if int(columns[1]) & 4 or int(columns[4]) < opts_mapq:
continue
segment = s.Segment(segmentID, columns[0], columns[1], columns[2],
columns[3], columns[4], len(columns[9]))
segment.parseCigar(cigar)
if float(segment.pid) < opts_pid:
continue
read.addSegment(segment)
segments[segmentID] = segment
segmentID += 1
def delineate_side(bfe_cross_sections, contours, side, workers):
# TODO - fill out doc string
"""
:param bfe_cross_sections:
:param contours:
:param side: string: LEFT or RIGHT
:param workers:
:return:
"""
# TODO - make this whole thing an object
# Set attribute names for LEFT vs RIGHT
if side == LEFT:
end_point = 'first_point'
extent = 'left_extent'
other_extent = 'right_extent'
elif side == RIGHT:
end_point = 'last_point'
extent = 'right_extent'
other_extent = 'left_extent'
else:
raise ValueError('side was set to ' + side + '. side must be ' + LEFT +
' or ' + RIGHT)
print '******** Working on', side, 'side'
# Find first valid bfe/cross_section
remaining_bfe_xs = None
for i, bfe_xs in enumerate(bfe_cross_sections):
last_bfe_xs = bfe_xs
if type(last_bfe_xs) is BFE:
last_position = 0.0
last_high_pt = getattr(last_bfe_xs, end_point)
last_low_pt = getattr(last_bfe_xs, end_point)
remaining_bfe_xs = bfe_cross_sections[i + 1:]
break
else: # cross section
last_position, last_high_pt, last_low_pt = _calc_extent_position(
last_bfe_xs, getattr(last_bfe_xs, extent),
getattr(last_bfe_xs, other_extent), contours)
if last_position >= 0:
remaining_bfe_xs = bfe_cross_sections[i + 1:]
break
if remaining_bfe_xs is None:
raise ValueError(
'Unable to find valid BFE/cross section in bfe_cross_sections.')
segments = []
boundary = []
# Loop through all the remaining BFE/XS
for current_bfe_xs in remaining_bfe_xs:
print '--- Segmenting last', last_bfe_xs.name, 'to current', current_bfe_xs.name
try:
orig_low_contour = contours.get(math.floor(last_bfe_xs.elevation))
orig_high_contour = contours.get(
math.ceil(current_bfe_xs.elevation))
# Calculate current high and low points for clipping contours
if type(current_bfe_xs) is BFE:
# current_high_pt is last vertex on BFE
current_position = 1
current_high_pt = getattr(current_bfe_xs, end_point)
# current_low_pt is found by intersecting current BFE w/ low contour
temp_low_contour = _closest_contour_segment(
orig_low_contour, getattr(current_bfe_xs, end_point))
current_low_pt = current_bfe_xs.geo.nearest_intersection(
temp_low_contour, getattr(current_bfe_xs, end_point))
else: # CrossSection
current_position, current_high_pt, current_low_pt = \
_calc_extent_position(current_bfe_xs, getattr(current_bfe_xs, extent),
getattr(current_bfe_xs, other_extent), contours)
# Ignore extent if outside of contours
if current_position < 0:
print 'Bad extent, ignoring.'
continue
# print 'last low pt',type(last_low_pt), last_low_pt, 'current_low_pt', type(current_low_pt), current_low_pt
# trim contours between current and last BFE/XS
low_contour = _clip_to_bfe(orig_low_contour, last_low_pt,
current_low_pt)
high_contour = _clip_to_bfe(orig_high_contour, last_high_pt,
current_high_pt)
# force contours to point upstream
_orient_contours(last_low_pt, low_contour)
_orient_contours(last_high_pt, high_contour)
if NEW_DEBUG:
low_contour.plot(color='black', linewidth=2)
high_contour.plot(color='red')
low_contour.first_point.plot(marker='o')
low_contour.last_point.plot(marker='o')
high_contour.first_point.plot(marker='o')
high_contour.last_point.plot(marker='o')
# Create segment and add to list
temp_seg = segment.Segment(low_contour, high_contour,
last_position, current_position)
temp_seg.current_feature = current_bfe_xs
temp_seg.last_feature = last_bfe_xs
segments.append(temp_seg)
except ComplexContourError:
print 'Funky contour - skipping'
except ContourNotFound:
print 'Contour not found'
except gt.UnknownIntersection:
print 'Contour doesn\'t intersect BFE/cross section'
except Exception as e:
print 'Unknown exception:', str(e)
# Reset for next BFE/XS
last_bfe_xs = current_bfe_xs
if type(last_bfe_xs) is BFE:
# BFE, last high is new low
last_low_pt = current_high_pt
# Hack, should extend BFE or intersect XS
last_high_pt = current_high_pt
else: # Cross section
last_low_pt = current_low_pt
# Hack, should extend BFE or intersect XS
last_high_pt = current_high_pt
if current_position == 1:
last_position = 0
else:
last_position = current_position
# ---------------- run segments -----------------
now = datetime.datetime.now()
if workers == 0: # Don't use SMP
print 'Delineating segments (no SMP)'
for current_segment in segments:
print str(current_segment)
result = current_segment.run()
result.status = 'testing'
boundary.append(result)
else:
pool = mp.ProcessingPool(workers=workers)
print 'Delineating', len(
segments), 'segments with', workers, 'sub processes.'
boundary = list(pool.map(segment.run_seg, segments))
time = datetime.datetime.now() - now
print 'Completed', len(segments), 'in', time, '.', (
time / len(segments)), 'per segment.'
for x in boundary:
x.status = 'testing'
return boundary
def __init__(self, sequence): super(CircularSequenceThread, self).__init__(traversal.Traversal(segment.Segment(sequence = X), True) for X in str(sequence))
import numpy as np import layerpot as ly import shapes as sh import segment as sg import mainpb as m nso = 400 a = 3 b = 2 def test_kress_k(t, tau, a, b): return - a * b / (2 * np.pi) /( a**2 + b**2 - (a**2 - b**2) * np.cos(t + tau) ) so = sg.Segment(nso, f_inargs = (sh.ellipse, (0, a, b)), quad='p') K = ly.layerpotSD_slf(s=so, t=sg.Pointset(x=[so.x[0]], nx=so.nx[0]), slf=1) i = sum(K[0]) # k = test_kress_k(so.t[0], so.t, a, b) err = [] for n in range(4, 50): so = sg.Segment(n, f_inargs = (sh.ellipse, (0, a, b)), quad='ps') K = ly.layerpotSD_slf(s=so, t=sg.Pointset(x=[so.x[0]], nx=so.nx[0]), slf=1) err.append(sum(K[0]) - i)
def __init__(self):
self.__segs.clear()
# create 5 segments to start
for i in range(glo.SNAKE_GROWTH_RATE):
self.__segs.append(segment.Segment(-i, 0, glo.Direction.RIGHT))
