Russian Qt Forum

C++ (Qt)
    boost::gil::rgb8_image_t img;
    boost::gil::read_image("photo.png", img, boost::gil::png_tag());
    boost::gil::rgb8_view_t view = boost::gil::view(img);
 

C++ (Qt)
std::random_device rd;
    std::mt19937 gen(rd());
 
    std::uniform_int_distribution<size_t> dist_x(0, view.width()-1);
    std::uniform_int_distribution<size_t> dist_y(0, view.height()-1);
 
    specmath::compsci::vanda vanda;
 
    auto start = std::chrono::high_resolution_clock::now();
 
    for (size_t i = 0; i < TRAINING_SIZE; ++i)
    {
        /* choose random pixel coordinates */
        size_t xi = dist_x(gen);
        size_t yi = dist_y(gen);
 
        boost::gil::rgb8_pixel_t pixel = view(xi, yi);
 
        /*
         * input data vec_t{xi, yi},
         * output data vec_t{R, G, B}
        */
        dataset.add( { double(xi), double(yi) },
                     { double(pixel[0]), double(pixel[1]), double(pixel[2]) } );
    }
 

C++ (Qt)
 /* radius = 3.0 */
    vanda.train(dataset, 3.0);
 

C++ (Qt)
void train(const training_dataset & dataset, const real_t & radius = 0.0)
    {
        if (dataset.empty())
            return;
 
        for (size_t i = 0; i < dataset.size(); ++i)
        {
            auto it = m_groups.begin();
            bool is_added = false;
 
            while (it != m_groups.end())
            {
                it = std::find_if(it, m_groups.end(), [&](const group_t & g)
                {
                    return g.is_contain(dataset[i].first, sqr(radius));
                });
 
                if (it != m_groups.end()) {
                    it->add( dataset[i].first, dataset[i].second );
                    is_added = true;
                    ++it;
                }
            }
 
            if (!is_added) {
                m_groups.emplace_front(dataset[i].first, dataset[i].second);
            }
        }
    }
 

C++ (Qt)
Т.е. если точка принадлежит групе, то происходит следующее:
void add(const vec_t & input, const vec_t & output)
        {
            ++m_count;
 
            for (size_t i = 0; i < m_stat.size(); ++i)
            {
                m_stat[i] += (output[i] - m_stat[i])/m_count;
            }
 
            for (size_t i = 0; i < m_basis.size(); ++i)
            {
                m_basis[i] += (input[i] - m_basis[i])/m_count;
            }
        }
 

C++ (Qt)
vec_t predict(const vec_t & data, const real_t & q = 0.5) const
    {
        if (m_groups.empty())
            return vec_t();
 
        if (m_groups.size() == 1)
            return m_groups.begin()->statistics();
 
        m_groups.sort( [&](const group_t & a, const group_t & b)
        {
            return a.sqr_distance_from(data) < b.sqr_distance_from(data);
        });
 
        vec_t stat(m_groups.begin()->statistics_size(), 0.0);
 
        real_t w = (1.0 - q)/(1.0 - std::pow(q, m_groups.size()));
 
        for (const auto & group : m_groups)
        {
            for (size_t j = 0; j < stat.size(); ++j)
            {
                stat[j] += w*group.statistics(j);
            }
            if (w < err)
                break;
            w *= q;
        }
 
        return stat;
    }
 

C++ (Qt)
n = 1 + log(err/(1-q))/log(q) + O(q^N)  // 0 < q < 1
 

C++ (Qt)
input_data = { {1, 2}, {12, -34}, {5, 7}, ..., {x_N, y_N} }
 

C++ (Qt)
index = (index + 1) % m_dimensions;
 

C++ (Qt)
    node* m_best = nullptr;
    real_t m_best_dist = 0.0;
 

C++ (Qt)
    vec_t predict(const vec_t & data, size_t tests = 10) const
    {
        size_t N = std::min(m_kdtree.num_nodes(), (tests) ? tests : size_t(1));
 
        vec_t output = m_kdtree.nearest(data).second;
 
        const real_t r = sqrt(3.0/m_kdtree.dimensions()) * m_kdtree.radius();
 
        std::uniform_real_distribution<real_t> dist(-r, r);
 
        for (size_t i = 1; i < N; ++i)
        {
            vec_t p = data;
            for (auto & x : p)
                x += dist(m_gen);
 
            auto stat = m_kdtree.nearest(p).second;
 
            for (size_t j = 0; j < output.size(); ++j)
            {
                output[j] += (stat[j] - output[j])/(i+1);
            }
        }
 
        return output;
    }
 

C++ (Qt)
void kd_tree::nearest( 
    const vec_t & ip,   // запросная точка
    double & ioRadius,   // напр -1 если начального R нет
    int iMaxNear;          // макс число ближайших (-1 если всех)
    std::vector<vec_t *> & outPt );   // вектор найденных ближайших
 

C++ (Qt)
index = (index + 1) % m_dimensions;
 

C++ (Qt)
index = (index + 1) % m_dimensions;
 
middle->m_left = make_tree(begin, middle, index); // Здесь индекс уже для следующей компоненты вектора
 
middle->m_right = make_tree(std::next(middle, 1), end, index);
 

C++ (Qt)
   struct CFindData {
     vec_t mPt;
     double mRad;
     int mMaxNear;
     std::vector<node *> mOut;
   };
 
    void nearest(node ** beg, node ** end, size_t index, CFindData & data )
    {
        auto num = end - beg;   // std::distance?
        if (num < 1)  return;
        node *& mid = *(beg + dist / 2);
 
        bool scanLeft = true, scanRight = true;
 
// пытаемся добавить точку
       data.AddPoint(mid);
        if (num < 2)  return;
 
// если радиус есть (был или появился после AddPoint),
// то отсекаем точки что заведомо далеко 
       if (data.mRad >= 0.0) {
         real_t dx = mid->get(index) - data.mPt[index];
 
         scanRight = (dx < data.mRad);
         scanLeft  = (dx > -data.mRad);
     }
 
     index = (index + 1) % m_dimensions;   // халтура
 
// продолжаем рекурсивно
     if (scanLeft)
        nearest(beg, &mid, index, data);
 
     if (scanLeft)
        nearest(&mid + 1, end, index, data);
   }
 

C++ (Qt)
bool CFindData::AddPoint( node * pt )
{
// гонорируем точку за границами радиуса
   double dist = pt->distance(mPt);
   if ((mRad >= 0.0) && (dist >= mRad)) return false;
 
// вставляем точку в сортированный вектор
   auto it = std::lower_bound(mOutPt.begin(), mOutPt.end(),  pt, CompDistFunc);
   mOutPt.insert(it, pt);
 
// вычисляем новый радиус
  if (mMaxNear > 0) {
     if (mOutPt.size() > mMaxNear)     
       mOutPt.resize(mMaxNear);
 
     if (mOutPt.size() >= mMaxNear)     
       mRad = mPt.distance(*mOutPt.back());
   }
   else
      assert(mRad >= 0.0);   // хотя бы 1 (mRad и mMaxNear) должен быть задан
 
   return true;
}