def run(self_queue: mp.Queue, arr, periscope: Periscope,
plane_loc: MirrorLocation, input_model: str):
model = load_model(
str(get_project_root()) + '\\src\\neuralnet\\' + input_model +
'_model.h5')
down = periscope.mirror_down.triangle
up = periscope.mirror_up.triangle
while True:
periscope.target = self_queue.get()
angles = model.predict(
numpy.array([[
periscope.target.location.y, periscope.target.location.z
]]))
periscope.mirror_down.triangle = down.rotate_plane(
angles[0][0], Angle.YAW)
periscope.mirror_down.triangle = periscope.mirror_down.triangle.rotate_plane(
angles[0][1], Angle.PITCH)
periscope.mirror_down.triangle = periscope.mirror_down.triangle.rotate_plane(
angles[0][2], Angle.ROLL)
periscope.mirror_up.triangle = up.rotate_plane(
angles[0][3], Angle.YAW)
periscope.mirror_up.triangle = periscope.mirror_up.triangle.rotate_plane(
angles[0][4], Angle.PITCH)
periscope.mirror_up.triangle = periscope.mirror_up.triangle.rotate_plane(
angles[0][5], Angle.ROLL)
self_plane = periscope.mirror_down.triangle
if plane_loc == MirrorLocation.UP:
self_plane = periscope.mirror_up.triangle
arr[0] = self_plane.point_b.x
arr[1] = self_plane.point_b.y
arr[2] = self_plane.point_b.z
arr[3] = self_plane.point_c.x
arr[4] = self_plane.point_c.y
arr[5] = self_plane.point_c.z
def write_log(self):
time_str = datetime.datetime.now().strftime("%d-%m-%Y_%H-%M")
f = open(
str(get_project_root()) + '\\logs\\' + time_str + '_log.txt', 'w')
f.writelines(self.log_list)
f.close()
def __init__(
self,
input_model: str = '2d',
algorithm: SolveAlgorithm = SolveAlgorithm.DIRECT,
mode: str = '',
):
self.log_list = []
pygame.init()
self.input_model = input_model
self.mode = mode
config = parse(input_model)
self.periscope: Periscope = Periscope(config)
p_target = self.periscope.ray_to_aim().intersect_plane(
Triangle(Point3d(0.4, 0.7, 0.2), Point3d(0.5, 0.4, 0.1),
Point3d(0.2, 0.6, 0.5)))
p_target = Point3d(0.62, 0.66, 0)
tee = Target(p_target, config["target_radius"])
self.periscope.set_target(tee)
self.renderer = Renderer(self.periscope)
# Shared memory
self.down_plane_points = mp.Array('d', 6)
self.up_plane_points = mp.Array('d', 6)
self.plane_3_points = mp.Array('d', 6)
self.__init_share_memory()
self.up_plane_queue = mp.Queue()
self.down_plane_queue = mp.Queue()
self.plane_3_queue = mp.Queue()
if algorithm == SolveAlgorithm.DIRECT:
self.up_plane_process: mp.Process = mp.Process(
target=DirectAlgorithm.plane_direct_process,
args=(self.up_plane_queue, self.up_plane_points,
self.periscope, MirrorLocation.UP))
self.down_plane_process: mp.Process = mp.Process(
target=DirectAlgorithm.plane_direct_process,
args=(self.down_plane_queue, self.down_plane_points,
self.periscope, MirrorLocation.DOWN))
self.plane_3_process: mp.Process = mp.Process(
target=DirectAlgorithm.plane_direct_process,
args=(self.plane_3_queue, self.plane_3_points, self.periscope,
MirrorLocation.THIRD))
else: # algorithm == SolveAlgorithm.NEURAL_NET:
from keras.models import load_model
from src.algorithms.net import NeuralNetAlgorithm
model = load_model(
str(get_project_root()) + '\\src\\neuralnet\\' +
self.input_model + '_model.h5')
self.up_plane_process: mp.Process = mp.Process(
target=NeuralNetAlgorithm.run,
args=(self.up_plane_queue, self.up_plane_points,
self.periscope, MirrorLocation.UP, model))
self.down_plane_process: mp.Process = mp.Process(
target=NeuralNetAlgorithm.run,
args=(self.down_plane_queue, self.down_plane_points,
self.periscope, MirrorLocation.DOWN, model))
self.plane_3_process: mp.Process = mp.Process(
target=NeuralNetAlgorithm.run,
args=(self.plane_3_queue, self.plane_3_points, self.periscope,
MirrorLocation.THIRD, model))