def main(): args = argparser.parse_arguments(ROOT_PATH) print('loading map') projector = lanelet2.projection.UtmProjector( lanelet2.io.Origin(args['lat_origin'], args['lon_origin'])) laneletmap = lanelet2.io.load(args['lanelet_map'], projector) criticalAreas = readCriticalAreas(args['critical_areas_file'], laneletmap) print('critical areas read: ') print( yaml.safe_dump( list(map(lambda x: x.toDict(), criticalAreas.critical_areas))))
def main() : args = argparser.parse_arguments(ROOT_PATH) print('loading map') projector = lanelet2.projection.UtmProjector(lanelet2.io.Origin(args['lat_origin'], args['lon_origin'])) laneletmap = lanelet2.io.load(args['lanelet_map'], projector) print('drawing map') fig, axes = plt.subplots(1, 1) fig.canvas.set_window_title("Map Visualization") drawing_utils.draw_lanelet_map(laneletmap, axes) plt.show()
def load_code(): ''' Loads the Befunge code from an external file. ''' ARGS = ap.parse_arguments() try: with open(ARGS.befunge_file, "r") as c: codelist = c.read().splitlines() if codelist: return codelist else: return [" "] except Exception as er: ap.parser.error(str(er))
def main(): args = argparser.parse_arguments(ROOT_PATH) print('loading map') projector = lanelet2.projection.UtmProjector( lanelet2.io.Origin(args['lat_origin'], args['lon_origin'])) laneletmap = lanelet2.io.load(args['lanelet_map'], projector) trafficRules = lanelet2.traffic_rules.create( lanelet2.traffic_rules.Locations.Germany, lanelet2.traffic_rules.Participants.Vehicle) graph = lanelet2.routing.RoutingGraph(laneletmap, trafficRules) print('analyzing map') # criticalAreas = map_analyzer.getAllConflictingAreas(laneletmap, graph) # divergingPoints = map_analyzer.getAllDivergingPoints(laneletmap, graph) # criticalAreas.extend(divergingPoints) criticalAreas = map_analyzer.getAllCriticalAreas( laneletmap, graph, args['critical_area_sim_thresh']) print('writing map analysis') writeOutCriticalAreas(criticalAreas, args['critical_areas_file'])
def main(): args = argparser.parse_arguments(ROOT_PATH) print('loading map') projector = lanelet2.projection.UtmProjector( lanelet2.io.Origin(args['lat_origin'], args['lon_origin'])) laneletmap = lanelet2.io.load(args['lanelet_map'], projector) trafficRules = lanelet2.traffic_rules.create( lanelet2.traffic_rules.Locations.Germany, lanelet2.traffic_rules.Participants.Vehicle) graph = lanelet2.routing.RoutingGraph(laneletmap, trafficRules) print('drawing map') fig, axes = plt.subplots(1, 1) fig.canvas.set_window_title("Map Visualization") drawing_utils.draw_lanelet_map(laneletmap, axes) print('analyzing map') criticalAreas = map_analyzer.getAllCriticalAreas(laneletmap, graph, 3.0) drawing_utils.draw_critical_areas(criticalAreas, axes) plt.show()
from prep import Preprocessor import pandas as pd from argparser import parse_arguments from dataset import Dataset from model import DeepPunctuation, DeepPunctuationCRF from config import * import augmentation from yttm import YTTM from lstm_model import BiLSTM_CNN_CRF from pqrnn import PQRNN from transformers import BertForSequenceClassification, BertConfig torch.multiprocessing.set_sharing_strategy('file_system') args = parse_arguments() # for reproducibility torch.manual_seed(args.seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False np.random.seed(args.seed) # tokenizer if args.yttm == 'false': tokenizer = MODELS[args.pretrained_model][1].from_pretrained( args.pretrained_model) else: tokenizer = YTTM(args.yttm) augmentation.tokenizer = tokenizer
def get_inputv(inp): input_stack = torch.FloatTensor().cuda() input_stack.resize_as_(inp.float()).copy_(inp) inputv = Variable(input_stack) return inputv app = Flask(__name__) CORS(app) # 解决跨域问题 # select device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) # code for TextureGAN command = '--display_port 7770 --load 0 --load_D -1 --load_epoch 105 --gpu 2 --model texturegan --feature_weight 1e2 --pixel_weight_ab 1e3 --global_pixel_weight_l 1e3 --local_pixel_weight_l 0 --style_weight 0 --discriminator_weight 1e3 --discriminator_local_weight 1e6 --learning_rate 1e-4 --learning_rate_D 1e-4 --batch_size 36 --save_every 50 --num_epoch 100000 --save_dir /home/psangkloy3/skip_leather_re/ --load_dir /home/psangkloy3/skip_leather_re/ --data_path ../../training_handbags_pretrain/ --learning_rate_D_local 1e-4 --local_texture_size 50 --patch_size_min 20 --patch_size_max 40 --num_input_texture_patch 1 --visualize_every 5 --num_local_texture_patch 1' args = parse_arguments(command.split()) args.batch_size = 1 args.image_size = 256 args.resize_max = 256 args.resize_min = 256 # args.data_path = '/home/psangkloy3/training_handbags_pretrain/' #change to your data path args.data_path = '/media/jay2019/DATA/Study/8.创新杯/3.现有代码/clothes_data/clothes_data' #args.data_path = './dataset/training_handbags_pretrain' #args.data_path = './dataset/training_shoes_pretrain' #args.data_path = './dataset/j_test_shoes' transform = get_transforms(args) # val = make_dataset(args.data_path, 'val') # valDset = ImageFolder('val', args.data_path, transform) # val_display_size = 1
feat_model.features, [layers_map[x.strip()] for x in args.style_layers.split(',')]) model = { "netG": netG, "netD": netD, "netD_local": netD_local, "criterion_gan": criterion_gan, "criterion_pixel_l": criterion_pixel_l, "criterion_pixel_ab": criterion_pixel_ab, "criterion_feat": criterion_feat, "criterion_style": criterion_style, "criterion_texturegan": criterion_texturegan, "real_label": real_label, "fake_label": fake_label, "optimizerD": optimizerD, "optimizerD_local": optimizerD_local, "optimizerG": optimizerG } for epoch in range(args.load_epoch, args.num_epoch): train(model, train_loader, val_loader, input_stack, target_img, target_texture, segment, label, label_local, extract_content, extract_style, loss_graph, vis, epoch, args) #break if __name__ == '__main__': args = argparser.parse_arguments() main(args)
def main(): from argparser import parse_arguments args = parse_arguments(ROOT_PATH) print(ROOT_PATH) processing_pipeline.startProcessingPipeline(args)
"g": lambda x1, x2: stackstack[-1].append(ord(the_field.get_char(x2, x1)))} # Global constants related to pygame CHAR_WIDTH = 12 CHAR_HEIGHT = 28 SCREEN_HEIGHT_MODIFIER = 300 SCREEN_HEIGHT = the_field.Y * CHAR_HEIGHT + SCREEN_HEIGHT_MODIFIER SCREEN_WIDTH = the_field.X * CHAR_WIDTH + 500 BG_COLOR = (52, 52, 52) STACK_BG_COLOR = (0, 0, 0, 100) STACK_OUTPUT_COLOR = (230, 200, 70) SOSS_OUTPUT_COLOR = (70, 230, 200) POINTER_COLOR = (255, 255, 255, 130) STACK_CHAR_HEIGHT = 16 STACK_CHAR_WIDTH = 10 ARGS = ap.parse_arguments() _paused = False _step_once = False _reset = False # Pygame surface inits if not ARGS.OUTPUT_MODE: screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) background = pygame.Surface(screen.get_size()).convert() pointer_rect = pygame.Surface((CHAR_WIDTH, CHAR_HEIGHT), pygame.SRCALPHA) pointer_rect.fill(POINTER_COLOR) stacksurf = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT_MODIFIER), pygame.SRCALPHA) outsurf = pygame.Surface((int(float(SCREEN_WIDTH) / 2.0), SCREEN_HEIGHT_MODIFIER), pygame.SRCALPHA)
def main(): from argparser import parse_arguments args = parse_arguments(ROOT_PATH) print(ROOT_PATH) print('loading map...') projector = lanelet2.projection.UtmProjector( lanelet2.io.Origin(args['lat_origin'], args['lon_origin'])) laneletmap = lanelet2.io.load(args['lanelet_map'], projector) trafficRules = lanelet2.traffic_rules.create( lanelet2.traffic_rules.Locations.Germany, lanelet2.traffic_rules.Participants.Vehicle) graph = lanelet2.routing.RoutingGraph(laneletmap, trafficRules) print('analyzing map...') criticalAreas = map_analyzer.getAllCriticalAreas( laneletmap, graph, args['critical_area_sim_thresh']) laneletCaDict = map_analyzer.createLaneletCriticalAreaDict(criticalAreas) print('loading trackfiles') track_dictionary = dataset_reader.read_tracks( args['interaction_trackfile']) timestamp_min = 1e9 timestamp_max = 0 timestamp_delta_ms = 100 for key, track in iter(track_dictionary.items()): timestamp_min = min(timestamp_min, track.time_stamp_ms_first) timestamp_max = max(timestamp_max, track.time_stamp_ms_last) timestamp = timestamp_min patchesDict = dict() textDict = dict() visualize = args['visualize'] while True: random_trackid = random.randint(1, len(track_dictionary)) if random_trackid in track_dictionary: print('trackid %s is found' % (random_trackid)) break random_trackid = 7 print(random_trackid) if visualize: fig, axes = plt.subplots(1, 1) fig.canvas.set_window_title("Prediction Visualization") drawing_utils.draw_fancy_lanelet_map(laneletmap, axes) drawing_utils.draw_critical_areas(criticalAreas, axes) title_text = fig.suptitle("") fig2, axes2 = plt.subplots(1, 1) # axes2.set_title("Data Visualization for random track: ",random_trackid) fig2.canvas.set_window_title("Data Visualization for track %s " % (random_trackid)) plt.xlim(track_dictionary[random_trackid].time_stamp_ms_first, track_dictionary[random_trackid].time_stamp_ms_last) #plt.ylim(-3.2, 3.2) plt.plot([ track_dictionary[random_trackid].time_stamp_ms_first, track_dictionary[random_trackid].time_stamp_ms_last ], [0, 0], c='k') colors = ['g', 'b', 'c', 'm', 'y', 'k', 'orange', 'aqua', 'lime'] markers = ['x', '+', 'v', '^', '1', '2', '3', '4', '5'] plt.ion() plt.show() activeObjects = dict() while timestamp < timestamp_max: if visualize: start_time = time.time() currentTracks = interaction_dataset_utilities.getVisibleTracks( timestamp, track_dictionary) possiblePathParams = lanelet2.routing.PossiblePathsParams() possiblePathParams.includeShorterPaths = True possiblePathParams.includeLaneChanges = False for track in currentTracks: currentMs = track.motion_states[timestamp] if track.track_id not in activeObjects: vehicleState = predictiontypes.Vehicle(objectId=track.track_id, motionState=currentMs, width=track.width, length=track.length) possiblePathsWithInfo = [] matchings = prediction_utilities.matchMotionState( laneletmap, currentMs) # match the car to several possible lanelets for match in matchings: # for each start lanelet possiblePathParams.routingCostLimit = lanelet2.geometry.approximatedLength2d( match.lanelet) + 150 paths = map( lambda x: predictiontypes.PathWithInformation( laneletPath=x, caDict=laneletCaDict), # caDict means conflict graph.possiblePaths(match.lanelet, possiblePathParams)) possiblePathsWithInfo.extend(paths) vehicleState.pathsWithInformation = possiblePathsWithInfo activeObjects[track.track_id] = vehicleState else: vehicleState = activeObjects[track.track_id] vehicleState.update(currentMs) prediction_utilities.removeInactiveObjects(activeObjects, timestamp) # TODO: continue here - calculate matching, build lanelet->critical area dictionary, associate track -> next ca, estimate state if visualize: plt.sca(axes) # plt.axis('off') # drawing_utils.draw_motion_states(track_dictionary, timestamp, axes, patchesDict, textDict) drawing_utils.draw_vehicle_states(activeObjects, axes, patchesDict, textDict) prediction_utilities.cleanDrawingDicts(activeObjects, patchesDict, textDict) # fig.canvas.draw() title_text.set_text("\nts = {}".format(timestamp)) if random_trackid in activeObjects.keys(): plt.sca(axes2) plt.title('Arc distance for all paths') basic_point = lanelet2.core.BasicPoint2d( track_dictionary[random_trackid].motion_states[timestamp]. x, track_dictionary[random_trackid]. motion_states[timestamp].y) in_area = 0 for i in range(len(criticalAreas.critical_areas)): area_center = lanelet2.core.BasicPoint2d( criticalAreas.critical_areas[i].x, criticalAreas.critical_areas[i].y) if lanelet2.geometry.distance( basic_point, area_center ) <= criticalAreas.critical_areas[i].radius: plt.scatter(timestamp, track_dictionary[random_trackid]. motion_states[timestamp].psi_rad, c='k', s=10, label='vehicle %s in critical area' % random_trackid) in_area = 1 break if in_area == 0: plt.scatter(timestamp, track_dictionary[random_trackid]. motion_states[timestamp].psi_rad, c='r', s=1, label='vehicle %s orientation' % random_trackid) for i in range( len(activeObjects[random_trackid]. arcCoordinatesAlongPaths)): # for each path arc_distance = activeObjects[ random_trackid].arcCoordinatesAlongPaths[i].distance plt.scatter(timestamp, arc_distance, c=colors[i], s=10, label='path arcCoordinate distance %s' % (i), marker=markers[i]) end_time = time.time() if timestamp == track_dictionary[ random_trackid].time_stamp_ms_first: plt.legend() plt.pause( max(0.001, timestamp_delta_ms / 1000. - (end_time - start_time))) timestamp += timestamp_delta_ms if visualize: plt.ioff() return
def main(): args = argparser.parse_arguments(ROOT_PATH) print('loading map') projector = lanelet2.projection.UtmProjector(lanelet2.io.Origin(args['lat_origin'], args['lon_origin'])) laneletmap = lanelet2.io.load(args['lanelet_map'], projector) trafficRules = lanelet2.traffic_rules.create(lanelet2.traffic_rules.Locations.Germany, lanelet2.traffic_rules.Participants.Vehicle) graph = lanelet2.routing.RoutingGraph(laneletmap, trafficRules) print('analyzing map') criticalAreas = map_analyzer.getAllCriticalAreas(laneletmap, graph, args['critical_area_sim_thresh']) laneletCaDict = map_analyzer.createLaneletCriticalAreaDict(criticalAreas) print('loading trackfiles') track_dictionary = dataset_reader.read_tracks(args['interaction_trackfile']) while True: randomTrackId = randint(1, 115) if randomTrackId not in track_dictionary: print('trackid %s not found' % (randomTrackId)) continue track = track_dictionary[randomTrackId] timestamp = track.time_stamp_ms_first vehicleState = predictiontypes.Vehicle(objectId=track.track_id, motionState=track.motion_states[timestamp], width=track.width, length=track.length) matchings = prediction_utilities.matchMotionState(laneletmap, track.motion_states[timestamp]) pathsWithInfo = [] possiblePathParams = lanelet2.routing.PossiblePathsParams() possiblePathParams.includeShorterPaths = True possiblePathParams.includeLaneChanges = False for match in matchings: possiblePathParams.routingCostLimit = lanelet2.geometry.approximatedLength2d(match.lanelet) + 150 paths = map(lambda x: predictiontypes.PathWithInformation(laneletPath=x, caDict=laneletCaDict), graph.possiblePaths(match.lanelet, possiblePathParams)) pathsWithInfo.extend(paths) vehicleState.pathsWithInformation = pathsWithInfo trackOrientations = [] timestamps = [] pathOrientations = [[] for j in range(len(pathsWithInfo))] dt = 100 while timestamp <= track.time_stamp_ms_last: timestamps.append(timestamp) trackOrientations.append(track.motion_states[timestamp].psi_rad) for i in range(len(pathsWithInfo)): basicPoint = lanelet2.core.BasicPoint2d(track.motion_states[timestamp].x, track.motion_states[timestamp].y) arcCoordinates = lanelet2.geometry.toArcCoordinates(pathsWithInfo[i].centerline, basicPoint) pathOrientations[i].append(pathsWithInfo[i].getOrientationAtArcLength(arcCoordinates.length)) timestamp += dt fig, axes = plt.subplots(1, 1) fig.canvas.set_window_title("Orientation of Track %s and its matching paths" % (randomTrackId)) plt.xlim(track.time_stamp_ms_first, track.time_stamp_ms_last) plt.ylim(-math.pi, math.pi) colors = ['g', 'b', 'c', 'm', 'y', 'k', 'orange', 'aqua', 'lime'] markers = ['x', '+', 'v', '^', '1', '2', '3', '4', '5'] plt.ion() plt.show() plt.sca(axes) plt.scatter(timestamps, trackOrientations, c='r', s=2, label='Track orientation') plt.plot(timestamps, trackOrientations, c='r') for i in range(len(pathsWithInfo)): plt.scatter(timestamps, pathOrientations[i], c=colors[i], label='Path number %s' % (i), marker=markers[i]) plt.plot(timestamps, pathOrientations[i], c=colors[i]) plt.legend() plt.waitforbuttonpress() plt.ioff()
def main(): from argparser import parse_arguments args = parse_arguments(ROOT_PATH) print(ROOT_PATH) print('loading map...') map_name = (args['lanelet_map'].split('/')[-1]).split('.')[0] trackfile = (args['interaction_trackfile'].split('/')[-1]).split('_')[-1] projector = lanelet2.projection.UtmProjector( lanelet2.io.Origin(args['lat_origin'], args['lon_origin'])) laneletmap = lanelet2.io.load(args['lanelet_map'], projector) trafficRules = lanelet2.traffic_rules.create( lanelet2.traffic_rules.Locations.Germany, lanelet2.traffic_rules.Participants.Vehicle) graph = lanelet2.routing.RoutingGraph(laneletmap, trafficRules) print('analyzing map...') criticalAreas = map_analyzer.getAllCriticalAreas( laneletmap, graph, args['critical_area_sim_thresh']) laneletCaDict = map_analyzer.createLaneletCriticalAreaDict(criticalAreas) print('loading trackfiles') track_dictionary = dataset_reader.read_tracks( args['interaction_trackfile']) timestamp_min = 1e9 timestamp_max = 0 timestamp_delta_ms = 100 for key, track in iter(track_dictionary.items()): timestamp_min = min(timestamp_min, track.time_stamp_ms_first) timestamp_max = max(timestamp_max, track.time_stamp_ms_last) timestamp = timestamp_min patchesDict = dict() textDict = dict() #parameter setting visualize = args['visualize'] Deviation_alongarcCoordinate = 4 Time_difference_max = 3 Time_gap = 5 Default_gap = 40 Distance_difference_max = 20 PathLengthLimit = 500 if visualize: fig, axes = plt.subplots(1, 1) fig.canvas.set_window_title("Prediction Visualization in %s for %s" % (map_name, trackfile)) drawing_utils.draw_fancy_lanelet_map(laneletmap, axes) drawing_utils.draw_critical_areas(criticalAreas, axes) title_text = fig.suptitle("") fig2, axes2 = plt.subplots(1, 1) fig2.canvas.set_window_title("Dependency Visualization in %s for %s" % (map_name, trackfile)) G = nx.DiGraph() plt.ion() plt.show() activeObjects = dict() while timestamp < timestamp_max: if visualize: start_time = time.time() currentTracks = interaction_dataset_utilities.getVisibleTracks( timestamp, track_dictionary) # possiblePathParams = lanelet2.routing.PossiblePathsParams() # possiblePathParams.includeShorterPaths = True # possiblePathParams.includeLaneChanges = False for track in currentTracks: currentMs = track.motion_states[timestamp] if track.track_id not in activeObjects: vehicleState = predictiontypes.Vehicle( objectId=track.track_id, motionState=currentMs, width=track.width, length=track.length, timestamp_first=track.time_stamp_ms_first) possiblePathsWithInfo = [] matchings = prediction_utilities.matchMotionState( laneletmap, currentMs) # match the car to several possible lanelets for match in matchings: # for each start lanelet #possiblePathParams.routingCostLimit = lanelet2.geometry.approximatedLength2d(match.lanelet) + 300 # a very important value. it means how far(meters) to consider # paths = map(lambda x: predictiontypes.PathWithInformation(laneletPath=x, caDict=laneletCaDict), # # caDict means conflict # graph.possiblePaths(match.lanelet, possiblePathParams)) #possiblePathsWithInfo.extend(paths) Pathset = possiblepath_calculate( matching=match, map_graph=graph, pathLengthLimit=PathLengthLimit) paths2 = map(lambda x: predictiontypes.PathWithInformation( laneletPath=x, caDict=laneletCaDict), Pathset) # caDict means conflict possiblePathsWithInfo.extend(paths2) vehicleState.pathsWithInformation = possiblePathsWithInfo activeObjects[track.track_id] = vehicleState else: vehicleState = activeObjects[track.track_id] vehicleState.update(currentMs) prediction_utilities.removeInactiveObjects(activeObjects, timestamp) # TODO: continue here - calculate matching, build lanelet->critical area dictionary, associate track -> next ca, estimate state if visualize: plt.sca(axes) drawing_utils.draw_vehicle_states(activeObjects, axes, patchesDict, textDict) prediction_utilities.cleanDrawingDicts(activeObjects, patchesDict, textDict) title_text.set_text("\nts = {}".format(timestamp)) dependency_node, dependency_edges, rightofway_info, front_car_pairs, conflicting_car_pairs = dependency_calculate( activeObjects, track_dictionary, timestamp, Default_gap, Deviation_alongarcCoordinate, Time_gap, Time_difference_max, Distance_difference_max) hidden_intention = hidden_intentions_initialize( activeObjects, front_car_pairs, conflicting_car_pairs, Deviation_alongarcCoordinate, Distance_difference_max) plt.sca(axes2) G.clear() axes2.cla() G.add_nodes_from(dependency_node) G.add_edges_from(dependency_edges) nx.draw_circular(G, with_labels=True) end_time = time.time() plt.pause( max(0.001, timestamp_delta_ms / 1000. - (end_time - start_time))) timestamp += timestamp_delta_ms if visualize: plt.ioff() return