Source code for logic.radar

import math
from typing import Optional

import glm

from logic.signal import Signal




class Emitter:
    """ The Emitter class

    Provides methods for emitter stimulation
    """

    def __init__(self, range_of_action: int,
                 characteristics: Optional[list] = None):
        self.range_of_action: int = range_of_action
        self.characteristics: list = characteristics
        self.fineness_of_coating = 20
        self.radiation_power = 150000  # Watt
        self.transmit_antenna_gain = 40  # decibel

        self.coordinates = []
        self._calculate_coordinates()

    def _calculate_coordinates(self):
        """ Calculate coordinates for signal """
        count, ci = 3, 2

        for j in range(self.fineness_of_coating + 1):
            radius = math.sin(j * math.pi / (2 * self.fineness_of_coating))
            z = math.cos(j * math.pi / (2 * self.fineness_of_coating)) + 10
            count += ci
            for i in range(count):
                first_angle = 2 * math.pi / count * i
                x, y = (math.cos(first_angle) * radius,
                        math.sin(first_angle) * radius)
                self.coordinates.append(glm.vec3(x, y, z))



    @staticmethod
    def send_signal(departure_time: int, direction: glm.vec3,
                    speed: glm.vec3, power_multiply: int = 0):
        """ Create Signal object

        :param departure_time: Time when the signal was emitted.
        :type departure_time: int
        :param direction: Vector of signal direction.
        :type direction: glm.vec3
        :param speed: Vector of signal speed.
        :type speed: glm.vec3
        :param power_multiply: Coefficient for power
        :type power_multiply: int
        :return: Signal object
        :rtype: Signal
        """
        signal = Signal(departure_time, direction, speed, power_multiply)
        return signal


    # send signals to half of sphere


    def send_signals(self, departure_time: int) -> list[Signal]:
        """ Send signal to half of sphere

        :param departure_time: Time of sending the signal.
        :type departure_time: int
        :return: List of signals
        :rtype: list[Signal]
        """
        signals = []
        for coordinate in self.coordinates:
            x, y, z = coordinate
            signals.append(self.send_signal(departure_time, glm.vec3(x, y, z),
                                            glm.vec3(x, y, z - 10)))
            if z <= 10.5:
                signals.append(self.send_signal(departure_time,
                                                glm.vec3(x, y, -z + 20),
                                                glm.vec3(x, y, -z + 10)))
        return signals






class Receiver:
    """ The Receiver class

    Provides object for emitter stimulation.
    """

    def __init__(self, radius: float, position: glm.vec3,
                 characteristics: Optional[list] = None):
        self.characteristics: Optional[list] = characteristics
        self.received_signals: list[Optional[Signal]] = []
        self.radius: float = radius
        self.position: glm.vec3 = position





class Radar:
    """ The Radar class

    Provides object for radar simulation.
    """

    def __init__(self,
                 emitter: Emitter = Emitter(80),
                 receiver: Receiver = Receiver(2, glm.vec3(0, 0, 10))):
        self.emitter: Emitter = emitter
        self.receiver: Receiver = receiver
        self.radius: int = 40