def __init__(self, mode=1, position=glm.vec3(1, 0, 0), target=glm.vec3(0), worldUp=glm.vec3(0, 1, 0)): # settings self.fpsRotationSpeed = 0.005 # speed with which the camera rotates in fps mode self.moveSpeed = 0.125 # speed with which the camera moves in fps mode self.tbRotationSpeed = 0.015 # speed with which the camera rotates in trackball mode self.panSpeed = 0.006 # speed with which the camera pans in trackball mode self.zoomSpeed = 0.25 # speed with which the camera zooms (used for Z axis in trackball mode) self.enableAllControls = False # enable movement while in trackball mode and pan/zoom while in fps mode self.movementSmoothing = 0.25 # higher numbers result in stronger smoothing and delayed movement self.rotationSmoothing = 0.3 # higher numbers result in stronger smoothing and delayed rotation self.worldUp = worldUp # worlds up vector self.mode = mode # 0 = trackball, 1 = first person self.movementSpeedMod = 1.0 # temporary modified movement speed, will be reset every frame # cameras internal state (DO NOT WRITE) self._movementInput = glm.vec3(0) self._rotationInput = glm.vec2(0) self._desiredTransform = Transform( ) # Transform(position) # desired transform based on inputs self._desiredTargetDistance = 0 # desired distance along the front vector where the center for trackball mode lives self._currentTransform = Transform( ) #Transform(position) # transform object describing orientation and position of camera self._currentTargetDistance = 0 # distance along the front vector where the center for trackball mode lives self.setPosition(position) self.setTarget(target) # variables depending on state, they are automatically updated when calling the Camera.update() (DO NOT WRITE, only read) self.modelMatrix = self._currentTransform.mat4() self.viewMatrix = glm.inverse(self.modelMatrix)
def test_rotate_vector(): v = Vec3(1, 1, 0) q1 = Quat.from_rotation_on_axis(0, np.pi / 3) q2 = Quat.from_rotation_on_axis(1, np.pi / 3) q3 = Quat.from_rotation_on_axis(2, np.pi / 3) t1 = Transform(q1, Vec3.zero()) t2 = Transform(q2, Vec3.zero()) t3 = Transform(q3, Vec3.zero()) # forward rotation v1 = t1.rotate(v) v2 = t2.rotate(v) v3 = t3.rotate(v) theta1 = (60) * np.pi / 180.0 v1_true = Vec3(1, math.cos(theta1), math.sin(theta1)) v2_true = Vec3(math.cos(theta1), 1, -math.sin(theta1)) theta2 = (45 + 60) * np.pi / 180.0 v3_true = math.sqrt(2) * Vec3(math.cos(theta2), math.sin(theta2), 0) assert v1 == v1_true assert v2 == v2_true assert v3 == v3_true # inverse rotate v1_rev = t1.inverse_rotate(v1_true) v2_rev = t2.inverse_rotate(v2_true) v3_rev = t3.inverse_rotate(v3_true) assert v == v1_rev assert v == v2_rev assert v == v3_rev
def test_finte(): q1 = Quat(10000000000, 210000000000, 310000000000, -2147483647) q2 = Quat(np.nan, 210000000000, 310000000000, -2147483647) q3 = Quat(np.inf, 210000000000, 310000000000, -2147483647) q4 = Quat(0.0, 210000000000, np.NINF, -2147483647) v1 = Vec3(10000000000, 210000000000, 310000000000) v2 = Vec3(np.nan, 210000000000, 310000000000) v3 = Vec3(np.inf, 210000000000, 310000000000) v4 = Vec3(0.0, 210000000000, np.NINF) t1 = Transform(q1, v1) assert t1.is_finite() assert not t1.is_nan() t2 = Transform(q1, v2) assert not t2.is_finite() assert t2.is_nan() t3 = Transform(q3, v1) assert not t3.is_finite() assert t3.is_nan() t4 = Transform(q4, v4) assert not t4.is_finite() assert t4.is_nan()
def __init__(self, content=None, parent=None): Element.__init__(self, content, parent) if isinstance(content, str): self._transform = Transform() self._computed_transform = self._transform else: self._transform = Transform(content.get("transform", None)) self._computed_transform = self._transform if parent: self._computed_transform = self._transform + self.parent.transform
def test_normalize(): q1 = Quat(0.4619398, 0.1913417, 0.4619398, 0.7325378) # 45 around X then Y then Z t1 = Transform(q1, Vec3.zero()) assert t1.is_normalized() q2 = Quat(3, 0, 4, 7) t2 = Transform(q2, Vec3.zero()) assert not t2.is_normalized() t2.normalize() assert t2.is_normalized()
def _build_model(self): """Build traning model. First embed user/item inputs into training dimension, then feed them in LSTMCell. Further affine the matrics into emission dimension after LSTM and emit the prediction. """ phase = 'ENCODE' with tf.variable_scope(phase): self.encode_user = Transform(self.user_input, self.user_hparas, phase) self.encode_item = Transform(self.item_input, self.item_hparas, phase) phase = 'LSTM' with tf.variable_scope(phase): self.lstm_user = LSTM(self.encode_user.output, self.user_hparas) self.lstm_item = LSTM(self.encode_item.output, self.item_hparas) phase = 'AFFINE' with tf.variable_scope(phase): self.trans_user = Transform(self.lstm_user.output, self.user_hparas, phase) self.trans_item = Transform(self.lstm_item.output, self.item_hparas, phase) phase = 'EMISSION' with tf.variable_scope(phase): self.dynamic_state = tf.einsum('ijl,kjl->jik', self.trans_user.output, self.trans_item.output, name='dynamic_state') self.stationary_state = tf.matmul(self.user_stationary_factor, self.item_stationary_factor, transpose_b=True, name='stationary_state') if self.loss_function == 'log_loss': logits = tf.add(self.dynamic_state * 0.5, self.stationary_state * 0.5, name='logits') self.logits = tf.nn.sigmoid(logits, name='logits_activation') elif self.loss_function == 'rmse': logits = tf.add(self.dynamic_state, self.stationary_state, name='logits') self.logits = tf.nn.relu(logits, name='logits_activation') else: raise NotImplementedError( "Didn't implement the loss function yet.") self.logits_last = self.logits[-1, :, :]
def __init__(self, trans=[0] * 6, vel=[0] * 6, radius=0.25): # cosmetic name, specific to this instance self.name = '' # set spatial member vars self.position = Transform(is_velocity=False, pos=trans[:3], rot=trans[3:]) self.velocity = Transform(is_velocity=True, pos=vel[:3], rot=vel[3:]) self.radius = 0.25 # set simulation parameters self.vote_exit = False self.force_exit = False # metrics; add to this for output self.metrics = dict()
def run_etl(filename): logger.info("application ran") start = time.time() app = Extract() raw_data_list = app.get_data_from_bucket(filename) # extract output end_extract = time.time() extract_time = round(end_extract - start, 4) print(f"Extract time: {extract_time}") logger.info(f"Extract time: {extract_time}") apple = Transform() transformed_data, transformed_drink_menu_data = apple.transform_new_data(raw_data_list) # raw data into transform returns transformed data and drinks dic end_transform = time.time() transform_time = round(end_transform - end_extract,4) logger.info(f"Transform time: {transform_time}") print(f"Transform time: {transform_time}") appley = Load() appley.save_transaction(transformed_data) # populate RDS instance with cleaned data. appley.save_drink_menu(transformed_drink_menu_data) # generate drinks menu end_load = time.time() load_time = round(end_load - end_transform, 4) logger.info(f"Loading time: {load_time}") total_time = extract_time + transform_time + load_time logger.info(f"total time: {total_time}") print(f"Load time: {load_time}\nTotal time: {total_time}")
def __init__(self, scene_mgr): self.scene_mgr = scene_mgr self.transform = Transform(self) self.components = {} self.children = [] self.parent = None
def main(args): workdir = Path(args.workdir) logger = get_logger() logger.info(f'config:\n{args}') state = Saver.load_best_from_folder(workdir, map_location='cpu') device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') logger.info(f'use device: {device}') num_points = len(args.data.symmetry) model = models.__dict__[args.model.name](num_points) model.load_state_dict(state['model']) model.to(device) # datasets valtransform = Transform(args.dsize, args.padding, args.data.meanshape, args.data.meanbbox) valdata = datasets.__dict__[args.data.name](**args.data.val) valdata.transform = valtransform valloader = DataLoader(valdata, args.batch_size, False, num_workers=args.num_workers, pin_memory=False) score_fn = IbugScore(args.left_eye, args.right_eye) evalmeter = evaluate(model, valloader, score_fn, device) logger.info(evalmeter)
def __init__(self, da): self.display_file = DisplayFile() self.draw_counter = 0 self.da = da da_width = da.get_allocation().width da_height = da.get_allocation().height # Window and viewport start with the same size as the drawing area, # but compensating for the clipping border size (otherwise you # wouldn't see by default a point drawn at 0,0). self.window = Window(-cbz, -cbz, da_width - cbz, da_height - cbz) self.viewport = Viewport(-cbz, -cbz, da_width - cbz, da_height - cbz) self.transform = Transform() # Pass reference to window for Transform and Viewport self.transform.setWindow(self.window) self.viewport.setWindow(self.window) # To verify that both normalize() and denormalize() work # print(self.transform.normalize(0,0)) # print(self.transform.normalize(self.window.getWidth(),self.window.getHeight())) # print(self.transform.denormalize(-1,-1)) # print(self.transform.denormalize(1,1)) self.projection = 'parallel'
def etl_fact_draw_main(engine_source, engine_target,chunksize=5000,record_file='etl_fact_draw.record'): """绘图事实表的ETL :param engine_source: 源数据库引擎 :param engine_target: 目标数据库引擎 """ extract = Extract(engine_source,chunksize,record_file) transform = Transform() load = Load(engine_target) # 抽取数据 df_industry,df_draw_gen = extract.extract_main() logging.info('Extract datasets completed.') for k,df_draw in enumerate(df_draw_gen,1): logging.info('Round %d, From obs.%d to obs.%d,start.' % \ (k, (k-1)*chunksize, k*chunksize)) # 清理、转换数据 df_clean = transform.transform_main(df_industry, df_draw) logging.info('Round %d, Data cleaning completed.'%k) try: load.load_main(df_clean) logging.info('Round %d, loading %d obs. Secceed '%(k,len(df_clean))) with open(record_file,'w') as f: f.write(str(max(df_draw['id']))) except Exception as e: df_clean[['drawGuid', 'marketGuid']].to_csv('unsecceed_samples.csv', mode='a',index=False) logging.error('Round %d,%s' %(k,e)) raise
def process_image(file_name, path, show): """ Loads a given image path, and applies the pipeline to it :param file_name: The name of the file (without extension) :param path: Path to the input (image, video) to process. :param show: Show the outcome :return: None """ # load the image image = cv2.imread(path, cv2.IMREAD_UNCHANGED) height, width = image.shape[:2] # initialize the objects threshold = Threshold() lane = Lane(height=height) camera = Camera(image_size=(width, height)) transform = Transform(width=width, height=height) # process the frame output = pipeline(image, camera, threshold, transform, lane) # save the output cv2.imwrite(f'data/processed/output_images/{file_name}.jpg', output)
def create(self, objDest): vertices = [] faces = [] # read file and get rid of '\n' at the end of each line. with open(objDest) as f: lines = f.readlines() lines = [line.strip() for line in lines] # parse vertices for line in lines: if line != '' and line[0] is 'v': vertexLine = line.split(' ') # create vertex vertices.append( Vec3D(float(vertexLine[1]), float(vertexLine[2]), float(vertexLine[3]), 1.0)) # parse faces for line in lines: if line != '' and line[0] is 'f': # find vertex indices faceElements = [int(e) for e in line.split(' ')[1:]] faceVertices = [] for faceElement in faceElements: faceVertices.append(vertices[faceElement - 1].clone()) # create face with color faces.append(Face3D(faceVertices, [0.6, 0.6, 0.8])) # create object with faces return Model3D( Transform(Vec3D(0.0, 0.0, 0.0, 1.0), Vec3D(0.0, 0.0, 0.0, 1.0), Vec3D(1.0, 1.0, 1.0, 1.0)), faces)
def __init__(self, teach_file, repeat_files=None, im_time_files=None, gps_files=None, gps_time_files=None): if repeat_files is None: repeat_files = [] if im_time_files is None: im_time_files = {} if gps_files is None: gps_files = {} if gps_time_files is None: gps_time_files = {} # Read teach run transforms from file transforms_temporal = np.loadtxt(teach_file, delimiter=",") self.teach_id = int(transforms_temporal[0, 0]) self.vertices = {} self.matches = {} # Add teach run vertices for row in transforms_temporal: transform = Transform(np.array([row[4:7], row[8:11], row[12:15]]), np.array([row[7], row[11], row[15]])) self.add_vertex(row[0], row[1], row[2], row[3], transform, True) self.add_prev_ids() # If repeat run transforms, add those to graph for run_file in repeat_files: self.add_run(run_file) self.add_timestamps(im_time_files) self.add_gps(gps_files, gps_time_files)
def __init__(self, fname='/dev/ttyACM0', brate=1000000, dim=(12, 10), gamma=2.2): """ Initialise a LedScreen object. >>> screen = LedScreen() """ if type(dim) not in (tuple, list) or len(dim) != 2: raise ValueError("Invalid dimension. Format is tuple(x,y)") self.tty = uspp.SerialPort(fname, timeout=0) #self.tty = uspp.SerialPort(fname, speed=brate, timeout=0) os.environ['LEDWALL_TTY'] = fname os.system("stty -F $LEDWALL_TTY " + str(brate)) self.w, self.h = dim self.buf = [(0, 0, 0)] * self.w * self.h self.transform = Transform(*dim) gamma = float(gamma) max_gamma = 255.**gamma self.gamma_map = [ int((1 + 2 * x**gamma / (max_gamma / 255.)) // 2) for x in xrange(256) ] for i, v in enumerate(self.gamma_map): if v == 254: self.gamma_map[i] = 253
def __init__(self): self._type = '' self._id = '' self._category = '' self._level = '' self.guid = guid() self.transform = Transform()
def etl_fact_macro_details(source_engine, target_engine): """fact_macro_details的etl主函数 从235 tag_detail表etl到240 fact_macro_details表 :param source_engine: 源数据库引擎 :param target_engine: 目标数据库引擎 """ extract = Extract(source_engine, target_engine) transform = Transform() load = Load(target_engine) record = Record(table='fact_macro_detail', record_path='rec.cfg') start_params = record.get_record() divisions = extract.std_divisions() for i in range(start_params['rounds']): start_id = start_params['update_id'] + i * start_params['chunksize'] + 1 end_id = start_params['update_id'] + ( i + 1) * start_params['chunksize'] + 1 tag_details = extract.tag_details(start_id, end_id) if len(tag_details) == 0: continue macro_details = transform.compile_datasets(tag_details, divisions) load.loading(macro_details) update_id = tag_details['id'].max() if tag_details['id'].max( ) else start_params['update_id'] record.update_record(update_id)
def test_init_and_eq_and_ne(): t1 = Transform() assert t1.rotation == Quat.identity() assert t1.translation == Vec3.zero() rot = Quat.from_rotation_on_axis(2, np.pi) trans = Vec3(1, 2, 3) t2 = Transform(rot, trans) assert t2.rotation == rot assert t2.translation == trans t3 = Transform.identity() assert t1 == t3 assert t1 != t2 assert t3 != t2
def __init__(self, xres, yres, title, fullscreen=False, vsync=False, samples=0): self._closeIssued = False self._window = None self.gameTime = 0 self.keyMap = defaultdict(lambda: False) self.mousePosition = vec2(0, 0) self.mouseDelta = vec2(0, 0) self.mouseWheelPosition = 0 self.cameraTransform = Transform() self.resolution = vec2(0, 0) self.updateObjects = [] self._init(xres, yres, title, fullscreen, vsync, samples) self.makeRenderStats = False self.renderStats = {}
def test_numpy_interop(): rot = Quat.from_rotation_on_axis(2, np.pi / 2) trans = Vec3(1, 1, 1) # fmt: off np_T = np.array([ [0, -1, 0, 1], [1, 0, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1], ]) # fmt: on T_a_b = Transform(rot, trans) T_a_b_from_mat4 = Transform.from_mat4_numpy(np_T) T_a_b_from_quatvec3 = Transform.from_quat_vec3_numpy( np.concatenate((rot.to_xyzw_numpy(), trans.to_numpy())) ) assert T_a_b == T_a_b_from_mat4 assert T_a_b == T_a_b_from_quatvec3 assert T_a_b_from_quatvec3 == T_a_b_from_mat4 np_mat4_T = T_a_b.to_mat4_numpy() np_quatvec3_T = T_a_b.to_quat_vec3_numpy() assert np.allclose( np_quatvec3_T, np.concatenate((rot.to_xyzw_numpy(), trans.to_numpy())) ) assert np.allclose(np_mat4_T, np_T)
def __init__(self): super().__init__() image_paths = sorted( glob('/home/ubuntu/FaceDatasets/jd/Training_data/*/picture/*.jpg')) landmarks_paths = sorted( glob( '/home/ubuntu/FaceDatasets/jd/Training_data/*/landmark/*.txt')) for i in range(len(image_paths)): assert image_paths[i].split('/')[-1].split( '.')[0] == landmarks_paths[i].split('/')[-1].split( '.')[0], 'CHECK ERROR' self.image_paths = image_paths self.landmarks_paths = landmarks_paths assert len(self.image_paths) == len( self.landmarks_paths), 'CHECK ERROR' self.COMPONETS = self.jdComponent() self.transform = Transform(degrees=30, scale=(0.75, 1.0), translate=(-0.05, 0.05), colorjitter=0.3, out_size=256, flip=True)
def applyTransform(self, transform): matrix = Transform().createMatrix(transform) (x1, y1) = matrix.applyOnPoint(self.xmin, self.ymin) (x2, y2) = matrix.applyOnPoint(self.xmax, self.ymax) self.reinit() self.addPoint(x1, y1) self.addPoint(x2, y2)
def transform_OK_callback(self): transform_appid = self.v_transform_appid.get() transform_apikey = self.v_transform_apikey.get() transform_audiopath = self.v_transform_audiopath.get() if transform_appid == "": self.t_transform_process.configure(state = "normal") self.t_transform_process.insert(END, "请输入APPID!\n") self.t_transform_process.see(END) self.t_transform_process.configure(state = "disabled") elif transform_apikey == "": self.t_transform_process.configure(state = "normal") self.t_transform_process.insert(END, "请输入APIkey!\n") self.t_transform_process.see(END) self.t_transform_process.configure(state = "disabled") elif transform_audiopath== "": self.t_transform_process.configure(state = "normal") self.t_transform_process.insert(END, "请选择音频文件!\n") self.t_transform_process.see(END) self.t_transform_process.configure(state = "disabled") else: #调用转写模块 T = Transform() th_transform = threading.Thread(target = T.start,args=(transform_appid,transform_apikey,transform_audiopath,self.t_transform_process,)) th_transform.setDaemon(True) th_transform.start()
def translate(self, x, y): transform = self.get('transform', default='') matrix = Transform().createMatrix(transform) matrix = matrix.add_translate(x, y) parser = Factory().create('transform_parser') transform = parser.unparse(matrix.createTransform()) self.set('transform', transform)
def calculate_order_position(order_pose, agv_id, incrementX=0, incrementY=0, incrementZ=0): tray_frame = TRAY_FRAME[agv_id] transform_part = Transform( [order_pose.position.x, order_pose.position.y, order_pose.position.z], [ order_pose.orientation.x, order_pose.orientation.y, order_pose.orientation.z, order_pose.orientation.w ]) transform_agv = global_vars.tf_manager.get_transform('world', tray_frame) final_position, final_rotation = transform.transform_to_world( transform_part, transform_agv) # moving to the middle of the tray final_position[0] += TRAY_POSITIONS2[agv_id][0] + incrementX final_position[1] += TRAY_POSITIONS2[agv_id][1] + incrementY final_position[2] += TRAY_POSITIONS2[agv_id][2] + incrementZ final_rotation = transf.transformations.euler_from_quaternion([ order_pose.orientation.x, order_pose.orientation.y, order_pose.orientation.z, order_pose.orientation.w ]) return final_position, final_rotation
def evaluate(): checkpoint_path = os.path.join(args.model_root, args.model_name) checkpoint = torch.load(checkpoint_path, map_location=device) model = SSD300(n_classes=len(label_map), device=device).to(device) model.load_state_dict(checkpoint['model']) transform = Transform(size=(300, 300), train=False) test_dataset = VOCDataset(root=args.data_root, image_set=args.image_set, transform=transform, keep_difficult=True) test_loader = DataLoader(dataset=test_dataset, collate_fn=collate_fn, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False, pin_memory=True) detected_bboxes = [] detected_labels = [] detected_scores = [] true_bboxes = [] true_labels = [] true_difficulties = [] model.eval() with torch.no_grad(): bar = tqdm(test_loader, desc='Evaluate the model') for i, (images, bboxes, labels, difficulties) in enumerate(bar): images = images.to(device) bboxes = [b.to(device) for b in bboxes] labels = [l.to(device) for l in labels] difficulties = [d.to(device) for d in difficulties] predicted_bboxes, predicted_scores = model(images) _bboxes, _labels, _scores = model.detect_objects(predicted_bboxes, predicted_scores, min_score=0.01, max_overlap=0.45, top_k=200) detected_bboxes += _bboxes detected_labels += _labels detected_scores += _scores true_bboxes += bboxes true_labels += labels true_difficulties += difficulties all_ap, mean_ap = calculate_mAP(detected_bboxes, detected_labels, detected_scores, true_bboxes, true_labels, true_difficulties, device=device) pretty_printer = PrettyPrinter() pretty_printer.pprint(all_ap) print('Mean Average Precision (mAP): %.4f' % mean_ap)
def pwmControlThread(): # setup arduino serial comm pwm.setPWMFreq(50) t = Transform(True, False) #invert one motor and not the other when constructing watchdog = time.time() # thread main loop while True: time.sleep(.005) # check for data that needs to be bridged to arduino dataFlag = True if not serialRealTimeQueue.empty(): data = serialRealTimeQueue.get() else: dataFlag = False # if data was recieved parse and update pwm hat if dataFlag: data = data[5:-1] print data data_nums = [int(x) for x in data.split(':') if x.strip()] print " ", data_nums[0], " ", data_nums[1] leftMtr,rightMtr = t.transform(data_nums[0],data_nums[1]) print " ", leftMtr , " ", rightMtr setServoPulse(LEFT_MOT, leftMtr) setServoPulse(RIGHT_MOT, rightMtr) Transform.MOTOR_MIN = data_nums[5]*10 Transform.MOTOR_IDLE = data_nums[6]*10 Transform.MOTOR_MAX = data_nums[7]*10 leftIntake = Transform.MOTOR_IDLE rightIntake = Transform.MOTOR_IDLE if data_nums[2] > 127 + 10: # if left trigger pressed (i think) spin motors in opposite direction leftIntake = Transform.map_range(data_nums[2],127,255,Transform.MOTOR_IDLE,Transform.MOTOR_MAX) rightIntake = Transform.map_range(data_nums[2],127,255,Transform.MOTOR_IDLE,Transform.MOTOR_MIN) elif data_nums[3] > 127 + 10: # if right trigger pressed leftIntake = Transform.map_range(data_nums[3],127,255,Transform.MOTOR_IDLE,Transform.MOTOR_MIN) rightIntake = Transform.map_range(data_nums[3],127,255,Transform.MOTOR_IDLE,Transform.MOTOR_MAX) else : leftIntake = Transform.MOTOR_IDLE rightIntake = Transform.MOTOR_IDLE print " " , leftIntake, " ", rightIntake setServoPulse(LEFT_MANIP,leftIntake) setServoPulse(RIGHT_MANIP,rightIntake) watchdog = time.time() if watchdog + WATCHDOG_DELAY < time.time(): setServoPulse(LEFT_MOT, Transform.MOTOR_IDLE) setServoPulse(RIGHT_MOT, Transform.MOTOR_IDLE) setServoPulse(LEFT_MANIP, Transform.MOTOR_IDLE) setServoPulse(RIGHT_MANIP, Transform.MOTOR_IDLE) watchdog = time.time() print "you need to feed the dogs"
def pwmControlThread(): # setup arduino serial comm pwm.setPWMFreq(50) t = Transform(True, False) watchdog = time.time() # thread main loop while True: # check for data that needs to be bridged to arduino dataFlag = True if not serialRealTimeQueue.empty(): data = serialRealTimeQueue.get() else: dataFlag = False # if data was recieved send it to arduino if dataFlag: data = data[5:-1] print data data_nums = [int(x) for x in data.split(':') if x.strip()] #print "have data" print " ", data_nums[0], " ", data_nums[1] leftMtr, rightMtr = t.transform(data_nums[0], data_nums[1]) print " ", leftMtr, " ", rightMtr setServoPulse(LEFT_MOT, leftMtr) setServoPulse(RIGHT_MOT, rightMtr) leftIntake = Transform.MOTOR_IDLE rightIntake = Transform.MOTOR_IDLE if data_nums[2] > 127 + 10: leftIntake = Transform.map_range(data_nums[2], 127, 255, Transform.MOTOR_IDLE, Transform.MOTOR_MAX) rightIntake = Transform.map_range(data_nums[2], 127, 255, Transform.MOTOR_IDLE, Transform.MOTOR_MIN) elif data_nums[3] > 127 + 10: rightIntake = Transform.map_range(data_nums[3], 127, 255, Transform.MOTOR_IDLE, Transform.MOTOR_MAX) leftIntake = Transform.map_range(data_nums[3], 127, 255, Transform.MOTOR_IDLE, Transform.MOTOR_MIN) print " ", leftIntake, " ", rightIntake setServoPulse(LEFT_MANIP, leftIntake) setServoPulse(RIGHT_MANIP, rightIntake) watchdog = time.time() if watchdog + WATCHDOG_DELAY < time.time(): setServoPulse(LEFT_MOT, Transform.MOTOR_IDLE) setServoPulse(RIGHT_MOT, Transform.MOTOR_IDLE) setServoPulse(LEFT_MANIP, Transform.MOTOR_IDLE) setServoPulse(RIGHT_MANIP, Transform.MOTOR_IDLE) watchdog = time.time() print "you need to feed the dogs"
def transform(args, x_queue, datadir, fname_index, joint_index, o_queue): trans = Transform(args) while True: x = x_queue.get() if x is None: break x, t = trans.transform(x.split(','), datadir, fname_index, joint_index) o_queue.put((x.transpose((2, 0, 1)), t))