std::vector<kernel::Vector> findBoundingPoints(kernel::Arc const& value)
    {
        PSVector start  = value.start,
                 middle = value.middle,
                 end    = value.end;
        EXPECT(start != middle && middle != end, "points which define arc must not coincide");

        auto t = middle - start,
             u = end    - start,
             v = end    - middle;

        auto w = t.cross(u);
        EXPECT(!w.isZero(), "points must define a plane in order to form an arc");

        // Calculate the center of the circumscribed circle
        auto center = start + (u * t.dot(t) * u.dot(v) - t * u.dot(u) * t.dot(v)) / (w.dot(w) * 2.0);
        auto s = start - center;
        auto e = end - center;

        // X vector is taken as pointing to the starting point
        // This way the parameter of the start is always zero
        auto x = s.normalized();
        auto y = w.cross(s).normalized();

        // Angle between start and end points is the parameter of the end point
        double se = atan2(s.cross(e).length(), s.dot(e));
        if (se < 0)
            se += M_PI * 2;

        // Collect all possible parameters of extrema
        // Dividing by zero is fine since it returns inf/-inf and atan(+-inf) is +-Pi/2
        std::vector<double> params {0.0, se};
        if (!math::equalEps(x.x, 0.0)) params.push_back(atan(x.x / y.x));
        if (!math::equalEps(x.y, 0.0)) params.push_back(atan(x.y / y.y));
        if (!math::equalEps(x.z, 0.0)) params.push_back(atan(x.z / y.z));
        for (double par: params) params.push_back(par + M_PI);

        // Evaluate points at all extrema parameters that lie between start and end parameters
        std::vector<PSVector> points;
        points.reserve(params.size());
        for (double par: params)
            if (par >= 0.0 && par <= se)
                points.push_back(center + s.length() * (cos(par) * x + sin(par) * y));

        return points;
    }