void ModelOperator::setDistance(Model& model, const Point3D& distance)
{
    model[DISTANCE] = distance.Scalar();
    Vector3D v = distance.direction();
    model[DISTANCE_ALPHA] = v.Alpha();
    model[DISTANCE_BETA] = v.Beta();
}
void ModelOperator::setTargetSpeed(Model &model, const Point3D& speed)
{
    model[TARGET_SPEED] = speed.Scalar();
    Vector3D v = speed.direction();
    model[TARGET_SPEED_ALPHA] = v.Alpha();
    model[TARGET_SPEED_BETA] = v.Beta();
}
void ModelOperator::setChaserSpeed(Model &model, const Point3D& speed)
{
    model[MISSLE_SPEED] = speed.Scalar();
    Vector3D v = speed.direction();
    model[MISSLE_SPEED_ALPHA] = v.Alpha();
    model[MISSLE_SPEED_BETA] = v.Beta();
}
Point3D operator*(Vector3D v, float scalar)
{
    float x = scalar * cos(v.Beta()) * sin(v.Alpha());
    float y = scalar * cos(v.Beta()) * cos(v.Alpha());
    float z = scalar * sin(v.Beta());
    return Point3D(x, y, z);
}
Point3D polarToDekart(float vector, Vector3D orientation)
{
    Point3D result(
                vector * std::cos(orientation.Beta()) * cos(orientation.Alpha()),
                vector * std::cos(orientation.Beta()) * sin(orientation.Alpha()),
                vector * std::sin(orientation.Beta()));
    return result;
}
Point2D CFlightVisualiser::getPlainCords(const Point3D &p)
{
    Vector3D view = _viewPoint;

    float alpha = -view.Alpha();
    float beta = -view.Beta();

    Point3D res = rotate(p, Vector3D(alpha, beta));
    return Point2D(res.Y(), res.Z());
}
Point3D rotate(const Point3D& p, const Vector3D &v)
{
    Util::Vector<float, 3> ini = {p.X(), p.Y(), p.Z()};
    float alpha = v.Alpha();
    float beta = v.Beta();

    Util::Matrix<float, 3, 3> rotateY = { std::cos(beta), 0, std::sin(beta),
                                          0             , 1, 0,
                                          -std::sin(beta), 0, std::cos(beta)};

    Util::Matrix<float, 3, 3> rotateZ = { std::cos(alpha), std::sin(alpha), 0,
                                          -std::sin(alpha), std::cos(alpha), 0,
                                          0             ,              0, 1};
    auto rotateMatrix = rotateY * rotateZ;

    auto res = rotateMatrix * ini;
    return Point3D(res[0], res[1], res[2]);
}
Vector3D operator-(const Vector3D& lhs, const Vector3D& rhs)
{
    return Vector3D(lhs.Alpha() - rhs.Alpha(), lhs.Beta() - rhs.Beta());
}