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))