Yalnızca özellikler için HG özellikleri

Question

HOG özelliklerini yalnızca blok için hesaplamaya çalışıyorum. opencv/module/gpu/src/ altında listelenen hog.cpp'u araştırdım. Aşağıda sadece blok özelliklerine göre değiştirdiğim kod var.

void cv::gpu::HOGDescriptor::getDescriptors(const GpuMat& img, Size win_stride, GpuMat& descriptors, int descr_format) 
{ 
    CV_Assert(win_stride.width % block_stride.width == 0 && win_stride.height % block_stride.height == 0); 

    computeBlockHistograms(img); 
    // give block back 

/* 
    const size_t block_hist_size = getBlockHistogramSize(); 
    Size blocks_per_win = numPartsWithin(win_size, block_size, block_stride); 
    Size wins_per_img = numPartsWithin(img.size(), win_size, win_stride); 

    descriptors.create(wins_per_img.area(), static_cast<int>(blocks_per_win.area() * block_hist_size), CV_32F); */ 

    switch (descr_format) 
    { 
    case DESCR_FORMAT_ROW_BY_ROW: 
     hog::extract_descrs_by_rows(win_size.height, win_size.width, block_stride.height, block_stride.width, 
            win_stride.height, win_stride.width, img.rows, img.cols, block_hists.ptr<float>(), descriptors); 
     break; 
    case DESCR_FORMAT_COL_BY_COL: 
     hog::extract_descrs_by_cols(win_size.height, win_size.width, block_stride.height, block_stride.width, 
            win_stride.height, win_stride.width, img.rows, img.cols, block_hists.ptr<float>(), descriptors); 
     break; 
    default: 
     CV_Error(CV_StsBadArg, "Unknown descriptor format"); 
    } 
} 

İşte computeBlockHistograms kodudur.

void cv::gpu::HOGDescriptor::computeBlockHistograms(const GpuMat& img) 
{ 
    computeGradient(img, grad, qangle); 

    size_t block_hist_size = getBlockHistogramSize(); 
    Size blocks_per_img = numPartsWithin(img.size(), block_size, block_stride); 

    // block_hists.create(1, block_hist_size * blocks_per_img.area(), CV_32F); 
    block_hists = getBuffer(1, static_cast<int>(block_hist_size * blocks_per_img.area()), CV_32F, block_hists_buf); 

    hog::compute_hists(nbins, block_stride.width, block_stride.height, img.rows, img.cols, 
         grad, qangle, (float)getWinSigma(), block_hists.ptr<float>()); 

    hog::normalize_hists(nbins, block_stride.width, block_stride.height, img.rows, img.cols, 
         block_hists.ptr<float>(), (float)threshold_L2hys); 
} 

DÜZENLEME: hog.cpp yanı getDescriptor fonksiyonunu dahil ediyorum

void cv::gpu::HOGDescriptor::getDescriptors(const GpuMat& img, Size win_stride, GpuMat& descriptors, int descr_format) 
{ 
    CV_Assert(win_stride.width % block_stride.width == 0 && win_stride.height % block_stride.height == 0); 

    computeBlockHistograms(img); 

    const size_t block_hist_size = getBlockHistogramSize(); 
    Size blocks_per_win = numPartsWithin(win_size, block_size, block_stride); 
    Size wins_per_img = numPartsWithin(img.size(), win_size, win_stride); 

    descriptors.create(wins_per_img.area(), static_cast<int>(blocks_per_win.area() * block_hist_size), CV_32F); 

    switch (descr_format) 
    { 
    case DESCR_FORMAT_ROW_BY_ROW: 
     hog::extract_descrs_by_rows(win_size.height, win_size.width, block_stride.height, block_stride.width, 
            win_stride.height, win_stride.width, img.rows, img.cols, block_hists.ptr<float>(), descriptors); 
     break; 
    case DESCR_FORMAT_COL_BY_COL: 
     hog::extract_descrs_by_cols(win_size.height, win_size.width, block_stride.height, block_stride.width, 
            win_stride.height, win_stride.width, img.rows, img.cols, block_hists.ptr<float>(), descriptors); 
     break; 
    default: 
     CV_Error(CV_StsBadArg, "Unknown descriptor format"); 
    } 
} 

birisi bloğu yalnızca HOG özellikleri almak için bana yardımcı olabilir. EDITED: Sadece hücre için farklı pencere boyutu tutma özelliklerini ve blok aynı HOG özelliklerini hesaplamak istiyorum.

Answer 1

HOG tanımlayıcılarını yalnızca bloklar için hesaplamak için aşağıdaki işlevleri değiştirdim.

void cv::gpu::HOGDescriptor::getDescriptorsBlock(const GpuMat& img, Size win_stride, GpuMat& descriptors, FileStorage fs3, string fileName, double scale, int width, int height, size_t lev) 
{ 
    CV_Assert(win_stride.width % block_stride.width == 0 && win_stride.height % block_stride.height == 0); 

    size_t block_hist_size = getBlockHistogramSize(); 
    computeBlockHistograms(img); 
    Size blocks_per_img = numPartsWithin(img.size(), block_size, block_stride); 

    // Size blocks_per_win = numPartsWithin(win_size, block_size, block_stride); 
    // Size wins_per_img = numPartsWithin(img.size(), win_size, win_stride); 

    // copy block_hists from GPU to CPU/ 

    float dest_ptr[block_hist_size * blocks_per_img.area()]; 

    cudaMemcpy(&dest_ptr[0], block_hists.ptr<float>(), block_hist_size *blocks_per_img.area()*sizeof(CV_32F),  cudaMemcpyDeviceToHost); 

    std::cout<<"("<<width<< " ," << height<< ")"<< std::endl; 
    std::cout <<lev<< std::endl; 

    // write to yml file 

    int level = lev; 

    fs3<<"Scale"<<scale; 
    fs3 <<"Level"<<level; 
    fs3<<"Width"<<width<<"Height"<<height; 
    fs3 << "features" << "["; 
    for (unsigned int i = 0; i < (block_hist_size * blocks_per_img.area()) ; i++) 
    { 
    fs3 << dest_ptr[i]; 
    } 
    fs3 << "]"; 
} 

Bu, çok ölçekli görüntü için HOG tanımlayıcılarını hesaplar.

void cv::gpu::HOGDescriptor::getDescriptorsMultiScale(const GpuMat& img, 
               Size win_stride, double scale0, unsigned int count) 
{ 

    CV_Assert(img.type() == CV_8UC1 || img.type() == CV_8UC4); 

    vector<double> level_scale; 
    double scale = 1.; 
    int levels = 0; 

    for (levels = 0; levels < nlevels; levels++) 
    { 
     level_scale.push_back(scale); 
     if (cvRound(img.cols/scale) < win_size.width || 
      cvRound(img.rows/scale) < win_size.height || scale0 <= 1) 
      break; 
     scale *= scale0; 
    } 
    levels = std::max(levels, 1); 
    level_scale.resize(levels); 
    image_scales.resize(levels); 

    // open yml file with image ID 

    FileStorage fs3; 
    char fileName[20]; 
    GpuMat descriptors; 
    sprintf (fileName, "%04d", count); 
    fs3.open(fileName, FileStorage::WRITE); 

    for (size_t i = 0; i < level_scale.size(); i++) 
    { 
     scale = level_scale[i]; 
     Size sz(cvRound(img.cols/scale), cvRound(img.rows/scale)); 
     GpuMat smaller_img; 

     if (sz == img.size()) 
      smaller_img = img; 
     else 
     { 
      image_scales[i].create(sz, img.type()); 
      switch (img.type()) 
      { 
       case CV_8UC1: hog::resize_8UC1(img, image_scales[i]); break; 
       case CV_8UC4: hog::resize_8UC4(img, image_scales[i]); break; 
      } 
      smaller_img = image_scales[i]; 
     } 
     std::cout<<"scale "<<level_scale[i]<<std::endl; 

     // calculate descriptors for blocks 
     getDescriptorsBlock(smaller_img, win_stride, descriptors, fs3, fileName, scale, smaller_img.cols, smaller_img.rows, i); 

     // detect(smaller_img, locations, hit_threshold, win_stride, padding); 
    } 
    // close yml file 
    fs3.release(); 

} 

bu iki fonksiyonların tanımını eklemek unutmayın opencv/modüller/gpu/include/opencv2/gpu