#main.py
from order import Order
from file_manager import FileManager
# 주문 내역 불러오고, 보여주자
# answer = input("주문 내역을 볼까요? (y/n) : ")
file_manager = FileManager("history.bin") # __init__
# if answer == "y":
history = []
try:
history = file_manager.load() # load()
sum = 0
for h in history:
print(h) # 리스트에서 하나씩 뽑아서 프린트
sum += h.price
print("여태까지 내가 아마스빈에 쏟아부은 돈 : " + str(sum) + "원")
except FileNotFoundError:
print("주문 내역이 없습니다.")
o = Order()
o.order_drink()
# 주문 내역 저장하자
file_manager.save(history + o.order_menu)
print(k1.multiply(3, 2))
print(k1.divide(3, 2))
# 6. Stwórz klasę ScienceCalculator, która dziedziczy po klasie Calculator i dodaj dodatkowe funkcje np. potęgowanie.
class ScienceCalculator(Calculator):
def power(self, a, b):
return a**b
def remain(self, a, b):
return a % b
k2 = ScienceCalculator()
print(k2.power(3, 5))
print(k2.remain(3, 5))
# 7. Stwórz funkcję, która wypisuje podany tekst od tyłu np. koteł -> łetok.
def reverse(text):
return text[::-1]
print(reverse("Ala ma kota"))
# 9. Zaimportuj klasę FileManager w innym pliku, a następnie zademonstruj działanie klasy.
fm = FileManager("plik.txt")
fm.read_file()
# sc = ScienceCalculator(2,3)
# print(ScienceCalculator.__doc__)
# print(sc.add())
# print(sc.powers())
# sc2 = ScienceCalculator(8,3)
# print(sc2.root())
# Zad7
def reverse(tekst):
"""
Funkcja wypisująca podany tekst od tyłu
:param tekst: zmienna typu string
:return: zmienna typu string
"""
return tekst[::-1]
print(reverse("koteł"))
# Zad8/9
fm = FileManager("test.txt")
fm.read_file()
fm.update_file(" Nowy tekst.")
# Zad10
print(chuck("BOB"))
def main():
superfamily = '3.20.20.70'
# Read input
# Embeddings for all 458 superfamilies considered in this study can be downloaded from
# ftp://rostlab.org/FunFamsClustering/sequences_funfams_ec_all_protbert_tucker.npy
embeddings_in = 'path_to_embeddings/sequences_funfams_ecs_all_protbert_tucker.npy'
embedding_ids_in = 'path_to_embeddings/sequences_funfams_ecs_all_protbert_tucker_ids.txt'
embeddings_tucker = Npy2Npz.get_dataset_uncompressed(
embeddings_in, embedding_ids_in)
# Read FunFam ids into a dictionary with key: superfamily, value: FunFams
funfams = FileManager.read_funfam_ids_with_family(
'example/funfams_ids.txt')
# Read sequence information per FunFam
sequence_info_in = 'example/sequences_funfams.txt'
sequences = FileManager.read_sequence_info(sequence_info_in,
embeddings_tucker.keys())
# The FunFams and sequence information can be directly extracted from FunFams and is included here to
# allow using the code without access to the FunFams alignments
fm = FileManager(
ungapped_aln_path='path_to_save_data_for_each_superfamily_to',
dist_path_funfam='path_to_save_distances_to')
# in the ungapped_aln_path directory, a sub-directory for each superfamily will be created.
# In the directory for a superfamily, a director dist_path_funfam will be created to save the distances to
# depending on the size of the FunFam, distance files can become rather large. Please make sure that enough
# disk space is available
# Calculate distances
print("Calculate distances")
dist_calculator = EmbeddingDistance(funfams, embeddings_tucker, sequences,
fm)
for f in funfams[superfamily]:
if len(sequences[f]) > 1:
dist_calculator.calc_distances_within_funfam(f, False)
# Determine distance threshold
print("Determine clustering cutoff")
cutoff_determine = CutoffDetermination(superfamily, funfams[superfamily],
None, fm)
cutoff = cutoff_determine.determine_cutoff(0.5, 'sequence')
print("Cutoff: {:.3f}".format(cutoff))
# Define clustering outputs
out_path = 'path_for_clustering_results'
cluster_out_prefix = '{}clustering_results/'.format(out_path)
outliers_out = '{}outliers.txt'.format(cluster_out_prefix)
cluster_out_suffix = '_median_seq_tucker_protbert.txt'
file_action = 'w'
if os.path.exists(cluster_out_prefix):
os.makedirs(cluster_out_prefix)
# Perform clustering
print("Perform clustering for each FunFam")
for f in funfams[superfamily]:
distance_file = '{}/{}/{}/{}_tucker_dist.npz'.format(
fm.ungapped_aln_path, superfamily, fm.dist_path_funfam, f)
if os.path.exists(distance_file):
distances = dict(np.load(distance_file, mmap_mode='r'))['dist']
if len(distances) > 0:
clustering = DBSCANClustering(distances)
cluster_results, outliers = clustering.calc_outliers_and_clustering(
cutoff)
# write output
FileManager.write_outliers(outliers_out, f, outliers,
file_action)
cluster_results.write_clustering_results(
f, cluster_out_prefix, cluster_out_suffix, file_action)
file_action = 'a' # append results to the previous file
def test_create_logs(self):
test_manager = FileManager("")
test_manager.create_logs("test", True, ["test"])
self.assertTrue(pathlib.Path("logs.txt").exists())
os.remove("logs.txt")
def test_create_dir_if_dosent_exist(self):
test_manager = FileManager("")
test_manager.create_dir_if_dosent_exist(test_manager.tmp_download_dir)
self.assertTrue(os.path.exists(test_manager.tmp_download_dir))
os.rmdir(test_manager.tmp_download_dir)
import logging
base_url = 'https://honourlogs.joachimveulemans.be'
origin = os.getenv('ORIGIN')
if origin is None:
origin = base_url
app = Flask(__name__)
CORS(app, supports_credentials=True, resources={
r"/*": {"origins": [base_url + ":443/*"]}})
logging.getLogger('flask_cors').level = logging.DEBUG
file_manager = FileManager("/var/www/public/current/logs.txt", "/var/www/public/deleted/")
@app.route("/")
def hello():
return "Logger is up & running!"
@app.route("/logs", methods=['GET', 'OPTIONS', 'DELETE'])
def call_get_logs():
if request.method == "OPTIONS":
return _build_cors_prelight_response()
if request.method == "GET":
return _build_cors_actual_response(jsonify(file_manager.get_json()))
if request.method == 'DELETE':
file_manager.clear()
def openpose_liftnet_other(current_state, pose_client, airsim_client,
potential_states_fetcher, file_manager, parameters):
potential_states_fetcher.reset(pose_client, airsim_client, current_state)
potential_states_fetcher.get_potential_positions(airsim_client.linecount)
num_of_loc = len(potential_states_fetcher.potential_trajectory_list)
len_of_sim = 80
validation_anims = ["28_19", "06_13", "13_06"]
openpose_array = np.zeros(
[len(validation_anims) * len_of_sim * num_of_loc, 2, 15])
gt_2d_array = np.zeros(
[len(validation_anims) * len_of_sim * num_of_loc, 2, 15])
lift_array = np.zeros(
[len(validation_anims) * len_of_sim * num_of_loc, 3, 15])
gt_lift_array = np.zeros(
[len(validation_anims) * len_of_sim * num_of_loc, 3, 15])
for anim_num in range(len(validation_anims)):
parameters["ANIMATION_NUM"] = validation_anims[anim_num]
file_manager = FileManager(parameters,
get_bone_len_file_name(pose_client.modes))
current_state.update_animation_gt_array(file_manager.f_anim_gt_array)
airsim_client.changeAnimation(ANIM_TO_UNREAL[file_manager.anim_num])
current_state.init_anim_time(airsim_client.default_initial_anim_time,
file_manager.anim_num)
set_animation_to_frame(airsim_client, pose_client, current_state,
airsim_client.default_initial_anim_time)
prev_drone_pose = torch.zeros([3, 1])
airsim_client.linecount = 0
while airsim_client.linecount < len_of_sim and anim_num != 0:
airsim_retrieve_gt(airsim_client, pose_client, current_state,
file_manager)
pose_client.immediate_future_pose = current_state.bone_pos_gt
pose_client.current_pose = current_state.bone_pos_gt
potential_states_fetcher.reset(pose_client, airsim_client,
current_state)
potential_states_fetcher.get_potential_positions(
airsim_client.linecount)
anim_time = airsim_client.getAnimationTime()
for trajectory_ind in range(num_of_loc):
# print(" ** traj ind", trajectory_ind)
index = anim_num * len_of_sim * num_of_loc + airsim_client.linecount * num_of_loc + trajectory_ind
#move
potential_states_fetcher.restart_trajectory()
goal_traj = potential_states_fetcher.choose_trajectory_using_trajind(
trajectory_ind)
set_position(goal_traj,
airsim_client,
current_state,
pose_client,
potential_states_fetcher,
loop_mode=potential_states_fetcher.loop_mode)
#update state values read from AirSim and take picture
take_photo(airsim_client, pose_client, current_state,
file_manager)
new_drone_pose = current_state.C_drone_gt.clone()
assert not torch.allclose(prev_drone_pose, new_drone_pose)
prev_drone_pose = new_drone_pose.clone()
#find 2d pose (using openpose and gt)
pose_2d_cropped, pose_2d_gt_cropped, heatmap_2d, cropped_image = determine_2d_positions(
pose_client=pose_client,
current_state=current_state,
my_rng=None,
file_manager=file_manager,
linecount=airsim_client.linecount)
openpose_array[index, :, :] = pose_2d_cropped.numpy().copy()
gt_2d_array[index, :, :] = pose_2d_gt_cropped.numpy().copy()
#find relative 3d pose using liftnet
pose_client.modes["mode_lift"] = "lift" #set this back
pose3d_lift_directions = determine_relative_3d_pose(
pose_client=pose_client,
current_state=current_state,
my_rng=None,
pose_2d=pose_2d_cropped,
cropped_image=cropped_image,
heatmap_2d=heatmap_2d,
file_manager=file_manager)
lift_array[index, :, :] = pose3d_lift_directions.numpy().copy()
pose_client.modes["mode_lift"] = "gt"
#find relative 3d pose using gt
pose3d_lift_directions_gt = determine_relative_3d_pose(
pose_client=pose_client,
current_state=current_state,
my_rng=None,
pose_2d=pose_2d_cropped,
cropped_image=cropped_image,
heatmap_2d=heatmap_2d,
file_manager=file_manager)
gt_lift_array[
index, :, :] = pose3d_lift_directions_gt.numpy().copy()
file_manager.save_openpose_and_gt2d(openpose_array, gt_2d_array)
file_manager.save_lift_and_gtlift(lift_array, gt_lift_array)
update_animation(airsim_client,
pose_client,
current_state,
delta_t=0.2)
airsim_client.increment_linecount(
pose_client.is_calibrating_energy)
def run_simulation(kalman_arguments, parameters, energy_parameters,
active_parameters):
"""
Description:
Main function that runs simulation
Inputs:
kalman_arguments: dict of kalman filter parameters that are now useless
parameters: dict of general parameters
energy_parameters: dict of pose estimation parameters
active_parameters: dict of active mode parameters
Returns:
errors: dict of errors
"""
# energy_parameters["MODES"]["mode_2d"] = "gt_with_noise"
bone_len_file_name = get_bone_len_file_name(energy_parameters["MODES"])
file_manager = FileManager(parameters, bone_len_file_name)
date_time_name = time.strftime("%Y-%m-%d-%H-%M")
print("experiment began at:", date_time_name)
length_of_simulation = parameters["LENGTH_OF_SIMULATION"]
loop_mode = parameters["LOOP_MODE"]
calibration_mode = parameters["CALIBRATION_MODE"]
port = parameters["PORT"]
simulation_mode = parameters["SIMULATION_MODE"]
experiment_ind = parameters["EXPERIMENT_NUMBER"]
#set random seeds once and for all
my_rng = rng_object(parameters["SEED"], file_manager.saved_vals_loc,
active_parameters["DRONE_POS_JITTER_NOISE_STD"],
energy_parameters["NOISE_3D_INIT_STD"])
#connect to the AirSim simulator
if simulation_mode == "use_airsim":
airsim_client = airsim.MultirotorClient(length_of_simulation,
port=port)
airsim_client.confirmConnection()
airsim_client.reset()
if loop_mode == "flight_simulation" or loop_mode == "try_controller_control":
airsim_client.enableApiControl(True)
airsim_client.armDisarm(True)
camera_offset_x = 45 / 100
else:
camera_offset_x = 0
airsim_client.initInitialDronePos()
airsim_client.changeAnimation(ANIM_TO_UNREAL[file_manager.anim_num])
if loop_mode == "flight_simulation" or loop_mode == "try_controller_control":
airsim_client.takeoffAsync(timeout_sec=15).join()
airsim_client.simSetCameraOrientation(
str(0), airsim.to_quaternion(0, 0, 0))
elif simulation_mode == "saved_simulation":
camera_offset_x = 0
if file_manager.anim_num == "drone_flight":
airsim_client = DroneFlightClient(
length_of_simulation, file_manager.anim_num,
file_manager.non_simulation_files)
elif file_manager.anim_num == "mpi_inf_3dhp":
airsim_client = MPI_Dataset_Client(length_of_simulation,
file_manager.test_sets_loc,
experiment_ind)
elif file_manager.anim_num == "cmu_panoptic_pose_1" or file_manager.anim_num == "cmu_panoptic_dance_3":
airsim_client = CMU_Panoptic_Dataset_Client(
file_manager.anim_num, length_of_simulation,
file_manager.test_sets_loc, experiment_ind)
else:
airsim_client = Synth_Dataset_Client(length_of_simulation,
file_manager.test_sets_loc,
file_manager.anim_num,
experiment_ind)
file_manager.init_photo_loc_dir(airsim_client.image_main_dir)
#file_manager.label_list = airsim_client.label_list
#pause airsim until we set stuff up
airsim_client.simPause(True, loop_mode)
pose_client = PoseEstimationClient(param=energy_parameters,
general_param=parameters,
intrinsics=airsim_client.intrinsics)
current_state = State(use_single_joint=pose_client.USE_SINGLE_JOINT,
active_parameters=active_parameters,
model_settings=pose_client.model_settings(),
anim_gt_array=file_manager.f_anim_gt_array,
future_window_size=pose_client.FUTURE_WINDOW_SIZE,
initial_drone_pos=airsim_client.DRONE_INITIAL_POS,
camera_offset_x=camera_offset_x)
potential_states_fetcher = PotentialStatesFetcher(
airsim_client=airsim_client,
pose_client=pose_client,
active_parameters=active_parameters,
loop_mode=loop_mode)
current_state.init_anim_time(airsim_client.default_initial_anim_time,
file_manager.anim_num)
set_animation_to_frame(airsim_client, pose_client, current_state,
airsim_client.default_initial_anim_time)
if airsim_client.is_using_airsim and not (loop_mode == "flight_simulation"
or loop_mode
== "try_controller_control"):
move_drone_to_front(airsim_client, pose_client, current_state.radius,
current_state.C_cam_torch)
airsim_retrieve_gt(airsim_client, pose_client, current_state, file_manager)
time.sleep(0.5)
if not calibration_mode:
pose_client.read_bone_lengths_from_file(file_manager,
current_state.bone_pos_gt)
file_manager.save_initial_drone_pos(airsim_client)
#shoulder_vector = initial_positions[R_SHOULDER_IND, :] - initial_positions[L_SHOULDER_IND, :] #find initial human orientation!
#INITIAL_HUMAN_ORIENTATION = np.arctan2(-shoulder_vector[0], shoulder_vector[1]) #in unreal coordinates
################
if loop_mode == "flight_simulation" or loop_mode == "teleport_simulation" or loop_mode == "toy_example":
general_simulation_loop(current_state, pose_client, airsim_client,
potential_states_fetcher, file_manager,
parameters, my_rng)
elif loop_mode == "openpose":
openpose_loop(current_state, pose_client, airsim_client,
potential_states_fetcher, file_manager, my_rng)
#elif loop_mode == "teleport":
# teleport_loop(current_state, pose_client, airsim_client, potential_states_fetcher, file_manager, loop_mode, parameters)
elif loop_mode == "save_gt_poses":
save_gt_poses_loop(current_state, pose_client, airsim_client,
file_manager)
elif loop_mode == "create_dataset":
create_test_set(current_state, pose_client, airsim_client,
potential_states_fetcher, file_manager, my_rng)
elif loop_mode == "try_controller_control":
try_controller_control_loop(current_state, pose_client, airsim_client,
file_manager, potential_states_fetcher,
loop_mode)
elif loop_mode == "openpose_liftnet":
openpose_liftnet(current_state, pose_client, airsim_client,
potential_states_fetcher, file_manager, parameters,
my_rng)
################
#calculate errors
airsim_client.simPause(False, loop_mode)
average_errors = pose_client.average_errors
ave_current_error, ave_middle_error, ave_pastmost_error, ave_overall_error = pose_client.average_errors[
pose_client.CURRENT_POSE_INDEX], pose_client.average_errors[
pose_client.MIDDLE_POSE_INDEX], pose_client.average_errors[
pose_client.PASTMOST_POSE_INDEX], pose_client.ave_overall_error
plot_distance_values(current_state.distances_travelled,
file_manager.plot_loc)
if calibration_mode:
file_manager.save_bone_lengths(pose_client.boneLengths)
print('End it!')
pose_client.reset(file_manager.plot_loc)
file_manager.close_files()
return ave_current_error, ave_middle_error, ave_pastmost_error, ave_overall_error
from file_manager import FileManager
from states import StartState, ExitState
if __name__ == "__main__":
manager = FileManager(url="http://127.0.0.1:8000", state=StartState())
while type(manager.curr_state) != ExitState:
manager.execute()
manager.execute()
#메뉴 보여주자
#음료주문하자
#주문한 음료 보여주자
#총금앱 계산하자
# 1. 음료 이름 가격
# 2. 컵 사이즈 레귤러 점보
# 3. 얼음량 0,50,100,150
# 4. 당도 0,50,100,150
# 5. 펄 타피오카, 코코,젤리, 알로에
from order import order
from file_manager import FileManager
#주문내역 불러오고 보여주자
file_manager = FileManager("history.bin")
# answer = input("주문내역을 볼까요?(y or n)")
# if answer == "y":
history = []
try:
history = file_manager.load()
sum = 0
for h in history:
print(h)
sum += h.price
print("여태까지 내가 아마스빈에 쏟아부은 돈: " + str(sum) + "원")
except FileNotFoundError:
print("주문 내역이 없습니다.")
o = order()
o.order_drink()
