def run(self, throttle): if throttle > 0: pulse = utils.map_range(throttle, 0, self.MAX_THROTTLE, self.zero_pulse, self.max_pulse) else: pulse = utils.map_range(throttle, self.MIN_THROTTLE, 0, self.min_pulse, self.zero_pulse) self.controller.set_pulse(pulse)
def optimize(points, model, loss_type=LossType.BEST_MATCH): num_steps = 500 optimizers = [ torch.optim.SGD(optimizer_param.params, lr=0.1, momentum=0.9) for optimizer_param in model.optimizer_config ] schedulers = [ (lambda x: torch.optim.lr_scheduler.LambdaLR( optimizer, lambda i: map_range(i, 0.0, num_steps - 1, x.start_lr, x .end_lr)))(optimizer_param) for (optimizer, optimizer_param) in zip(optimizers, model.optimizer_config) ] model.train() # Uncomment the line below in the event of an anomaly detection #with torch.autograd.detect_anomaly(): for i in range(num_steps): model.lambda_ = map_range(i, 0, num_steps - 1, 0.01, 8.0) for optimizer in optimizers: optimizer.zero_grad() loss = model(points, loss_type=loss_type) print("Loss: " + str(loss)) if math.isnan(loss.item()): raise NumericalInstabilityException( "Loss score was NaN. Consider using torch.autograd.detect_anomaly() to track down the source of the NaN" ) loss.backward() # Occasionally the gradient can blow up, so clip it here to make # sure we don't jump too far around the parameter space torch.nn.utils.clip_grad_norm_(model.parameters(), 10.0) for optimizer in optimizers: optimizer.step() model.normalize() for scheduler in schedulers: scheduler.step() # Don't use the raw loss score since the different geometric models may have different incomparable loss scores # (like comparing apples to oranges) return model.exact_forward(points, loss_type=loss_type)
def send_control(): control_input = request.args logger.debug('control input: {}'.format(control_input)) if 'steer' in control_input: steer = map_range(int(control_input['steer']), -100.0, 100.0, -1.0, 1.0) self.steering = steer if 'throttle' in control_input: throttle = map_range(int(control_input['throttle']), -170.0, 170.0, -1.0, 1.0) self.throttle = throttle if 'record' in control_input: self.record = str(control_input['record']) == 'true' if 'auto' in control_input: self.autonomous = str(control_input['auto']) == 'true' self.publish_message(self.steering, self.throttle, self.record, self.autonomous) return ''
def run(self, angle): #map absolute angle to angle that vehicle can implement. pulse = utils.map_range(angle, self.LEFT_ANGLE, self.RIGHT_ANGLE, self.left_pulse, self.right_pulse) self.controller.set_pulse(pulse)
def predict_img(net, ldr_img, scale_factor=0.5, out_threshold=0.5, use_dense_crf=True, use_gpu=False, output_path: '', tone_map: 'durand'): img_height = ldr_img.size[1] img_width = ldr_img.size[0] # preprocess img = ldr_img.astype('float32') img = only_resizeCV(img,224,224) ldr_input = map_range(img) t_ldr = cv2torch(ldr_input) if use_gpu: t_ldr = t_ldr.cuda() with torch.no_grad(): pred = net(t_ldr) pred = map_range(torch2cv(pred).cpu(),0,1) # extension = 'exr' if opt.use_exr else 'hdr' extension = 'hdr' out_name = create_name(ldr_img,'prediction_{0}'.format(),extension,output_path) print(f'Writing {out_name}') cv2.imwrite(out_name, pred) tmo_img = tone_map(pred,tone_map,**create_tmo_param_from_args(tone_map)) out_name = create_name( ldr_img, 'prediction_{0}'.format(tone_map), 'jpg', output_path ) cv2.imwrite(out_name, (tmo_img * 255).astype(int)) if use_dense_crf: full_mask = dense_crf(np.array(ldr_img).astype(np.uint8), full_mask) return full_mas k > out_threshold
def set_motor(self, motor_number, value): if self.motor_controller is not None: motor = self.motor_controller.devices[motor_number] value = self.apply_sensitivity(value) pwm_value = int(map_range(value, -1.0, 1.0, FULL_REVERSE, FULL_FORWARD)) # print("setting motor {0} to {1}".format(motor_number, pwm_value)) motor.off = pwm_value
def on_message(self, channel, throttle): if throttle == 0: pca9685.set_throttle(self.channel, 0) elif throttle is not None: pca9685.set_throttle( self.channel, map_range(throttle, -1, 1, self.min_throttle, self.max_throttle))
def update_button(self, button, value): if button == UP: self.light = min(1.0, self.light + LIGHT_STEP) elif button == DOWN: self.light = max(0.0, self.light - LIGHT_STEP) elif button == RESET: self.light = 0.0 light_value = map_range(self.light, 0.0, 1.0, -1.0, 1.0) print("button %s, light = %s, light_value = %s" % (button, self.light, light_value)) self.set_motor(LIGHT, light_value)
def run(self, angle): if self.invert_steering_angle: if angle != 0.0: angle = 1 / angle # map absolute angle to angle that vehicle can implement. pulse = utils.map_range(angle, self.LEFT_ANGLE, self.RIGHT_ANGLE, self.left_pulse, self.right_pulse) self.controller.set_pulse(pulse)
def on_message(self, channel, angle): """ Args: channel: angle: float: -1 to 1 """ if angle == 0: pca9685.set_angle(self.channel, self.straight_angle) elif angle is not None: # pca9685.set_angle( self.channel, int( map_range(angle, self.MIN_STEERING, self.MAX_STEERING, self.full_left_angle, self.full_right_angle)))
def run(self, speed): ''' Update the speed of the motor where 1 is full forward and -1 is full backwards. ''' if speed > 1 or speed < -1: raise ValueError( "Speed must be between 1(forward) and -1(reverse)") self.speed = speed self.throttle = int(utils.map_range(abs(speed), -1, 1, -255, 255)) if speed > 0: self.motor.run(self.FORWARD) else: self.motor.run(self.BACKWARD) self.motor.setSpeed(self.throttle)
# Cool, we detected a single hand. Update the coordinates and open status landmarks = multi_hand_landmarks[0].landmark # Get the hand open status if get_average_knuckle_distance(landmarks) >= MIN_HAND_OPEN_DISTANCE: hand_open = True else: hand_open = False palm_coordinates_unmapped = get_palm_coordinate(landmarks) cv2.putText(image, "Hand open" if hand_open else "Hand closed", (20, 70), cv2.FONT_HERSHEY_PLAIN, 1, (0, 0, 255), 1, cv2.LINE_AA) # Get the coordinates of the palm draw_palm_coordinates = (int(palm_coordinates_unmapped[0] * image.shape[1]), int(palm_coordinates_unmapped[1] * image.shape[0])) mapped_palm_x = (int)(map_range( palm_coordinates_unmapped[0], margined_start_point[0] / image.shape[1], margined_end_point[0] / image.shape[1], 0, MAPPED_WIDTH)) mapped_palm_y = (int)(map_range( palm_coordinates_unmapped[1], margined_start_point[1] / image.shape[0], margined_end_point[1] / image.shape[0], 0, MAPPED_HEIGHT)) palm_coordinates = (mapped_palm_x, mapped_palm_y) # Draw a purple circle at the palm cv2.circle(image, draw_palm_coordinates, 15, (255, 0, 255), cv2.FILLED) hands_detected = 1 else: hands_detected = 0 cv2.imshow('Hand detection', image) send_payload = True if cv2.waitKey(5) & 0xFF == 27: break
period_time = time.monotonic() wave_inc = 8 # let's declare our "dt" to always be 0.01 secs, THEN # what wave part do I pick for given period # dt = 0.001 wave_dt = period / len(wave) #print("steps:",len(wave), "period:",period, "dt:",dt,"period_dt:",wave_dt, "wave_inc:",wave_inc) base_dt = 0.001 dtcnt=0 while True: wave_dt = max(0, utils.map_range(knob_a.value, (65500,150), (0.001, 0.25))) volt_amplitude = utils.map_range(knob_b.value, (150,65500), (0.1,5) ) # period = max(0, utils.map_range(knob_a.value, (150,65500), (0.1, 20))) # wave_dt = wave_inc * period / len(wave) #if wave_dt*2 < dt: # wave_inc = 2*wave_inc # wave_dt = 2*wave_dt wave_inc = max(1,utils.map_range(wave_dt, (0,0.1), (16,1))) # this is a float dt = wave_dt / wave_inc wave_inc = int(wave_inc) wave_index = (wave_index + wave_inc) % len(wave) print("steps:",len(wave), "wave_inc:",wave_inc,"period:",period, "wave_dt:",wave_dt, "dt:",dt)