Roi C++ ile sürgülü pencere

Question

Aşağıdaki for döngüsü ile çok az indeksleme problemim var. Sadece görüntüyü roi ile tarıyorum ama bütün görüntüyü tarayamıyorum. Son satırlarda ve sütunlarda kalan taranmamış bölgeler var. Herhangi bir öneri? Basit soru için özür dilerim.

int getNextIndex(int currentIndex, int frameSize, int roi, int step) 
{ 
    int temp = min(currentIndex + step, frameSize - roi - 1); 
    return currentIndex != temp ? temp : frameSize; 
} 

0: fonksiyon getNextIndex böyle olduğu Yerine bu

for (int rowindex = 0; rowindex <= frameWidth - roiw; rowindex += StepRow) 

ait

// Sliding Window for scaning the image 
for (int rowIndex = 0; rowIndex <= lBPIIImage2.rows - roih; rowIndex = getNextIndex(rowIndex, lBPIIImage2.rows, roih, steprow)) 

{ 
    for (int colindex = 0; colindex <=lBPIIImage2.cols - roiw; colindex = getNextIndex(colindex, lBPIIImage2.cols, roiw, stepcol)) 

    { 
     searchRect = cvRect(colindex, rowIndex, roiw, roih); 
     frameSearchRect = lBPIIImage2(searchRect); 
     LoopDummy = frameSearchRect.clone(); 
     rectangle(frame, searchRect, CV_RGB(255, 0, 0), 1, 8, 0); 
     //normalize(LoopDummy, LoopDummy, 0, 255, NORM_MINMAX, CV_8UC1); 
     //imshow("Track", LoopDummy); 
     //waitKey(30); 
     images.push_back(LoopDummy); 
     Coordinate.push_back(make_pair(rowIndex, colindex)); 
    } 

} 

Answer 1

`

bu

for (int rowIndex = 0; rowIndex < frameWidth - roiw; 
    rowIndex = getNextIndex(rowIndex, frameWidth, roiw, StepRow)) 

gibi bir şey denemek

Döngünün koşulunda <='u < ile değiştirdiğimi unutmayın. O bit'i değiştirmek benim için mantıklı. Benim yorumlar indeks değerleri 0,5,7 yerine 0,5,6 olmalıdır. Eğer gerçekten <= durması gerekiyorsa, yukarıdaki - 1 bölümünü kaldırmanız yeterlidir.

Answer 2

Dialecticus, problem covered ürününe sahiptir, ancak biraz genişletmek istiyorum. Sorun, fark ettiğiniz gibi, hem satırları hem de sütunları etkiler, ancak yükseklik kullanımı benzer olduğundan sadece genişliği hakkında konuşacağım. Bir döngü tarafından yinelenmeyen bir dizinin veya aralığın parçaları, özellikle de sonunda olanlar, döngü koşulunun ve/veya artışının tüm diziyi/aralığı kapsamayacağı ve ayarlamaya ihtiyaç duyduğu tipik bir belirtidir. Durumunuzda, tüm görüntü genişliğini taramak için, StepRow s, yani (frameWidth - roiw) % StepRow == 0 tam sayısı olmak için frameWidth - roiw'a ihtiyacınız vardır. Davanızda bunun doğru olmadığını sanmıyorum. Resim 14 piksel genişliğinde ve faiz genişliğinin Bölgeyi bu durumda üvey would be 4 pixels içinde (Sana roiw * 0.5 demek varsayalım), 8 ise

Örneğin, o zaman bunun olacağını:

Yineleme # 3, rowindex <= frameWidth - roiw testini başarısız olur ve son 2 pikseli taramadan döngüden çıkar.

Yasal Uyarı::

Ben üç seçenek, onun dezavantajları her aşağıya bakın tüm kod test edilmemiştir ve hatalardan ve mantıksal hatalar içerebilir. Lütfen test edin ve buna göre ayarlayın. resmin sonunu uyuyor böylece

1. Değişim geçen bölgenin ofset. Bu durumda, son rowindex artış, StepRow değil, son tarama bölgesinin sonu ile resmin sonu arasındaki piksel sayısı olmaz. Bunun dezavantajı, son iki bölgenin onlardan öncekilerden daha fazla çakışabileceğidir - bizim durumumuzda, bölge 1, pikseller 0: 7, bölge 2 - 4:11 ve bölge 3 - 6:13'ü kapsayacaktır.

   Bunu yapmak için, bu son yineleme olup olmadığını kontrol etmek için döngü artışı değiştirebilirsiniz (daha güzel görünüm yazma düşünmek lütfen, sadece yapmak için üçlü operatörü kullanılan değişim daha az):

   for (int rowindex = 0; 
       /* Note that a region of (roiw) pixels ending at (frameWidth - 1) should start 
        at (frameWidth - roiw), so the <= operator should be correct. To verify that, 
        check the single-region case where rowindex == 0 and frameWidth == roiw */ 
       rowindex <= frameWidth - roiw; 
       rowindex += ((rowindex + roiw + StepRow <= frameWidth) ? 
          StepRow : 
          (frameWidth - (rowindex + roiw)))) 
   

2. Son bölgenin boyutunu görüntünün sonuna kelepçeleyin. Bunun dezavantajı, son bölgenizin önündeki değerlerden daha küçük olmasıdır - bizim durumumuzda, 1 ve 2 bölgeleri 8 büyüklüğündeyken, 3 bölgesi 6 piksel olacaktır.

   Bunu yapmak için, daha küçük olması gerekip gerekmediğini görmek için cvRect'u oluştururken bir kontrol ekleyebilirsiniz.

   /* (StepRow - 1) should make sure that enter the loop is entered when the 
       last unscanned region has a width between 1 and stepRow, inclusive */ 
   for (int rowindex = 0; rowindex <= frameWidth - roiw + (StepRow - 1); rowindex += StepRow) 
   /* ... column loop ... */ 
       { 
       if (rowindex > frameWidth - roiw) 
       { 
        roiw = frameWidth - rowindex; 
       } 
       searchRect = cvRect(rowindex, colindex, roiw, roih) 
   

3. sizin bölgeler eşit genişliktedir böylece değişen adımı kullanın ve mümkün olduğunca eşit örtüşüyor: aslında bu durumda girmek, böylece de, bir şekilde sizin döngü koşulunu değişmelidir. Bizim durumumuzda, üç bölge eşit olarak örtüşecek, 0: 7, 3:11 ve 6:14 piksellerde olacak, fakat çoğu durumda bu doğru olmayacaktır.

   Bunu yapmak için, geçerli adımınızla ne kadar beklemeyi beklediğinizi hesaplayabilir ve ardından bu sayıya, kare ve ROI genişliğiniz arasındaki farkı bölerek kesirli adımınızı atabilirsiniz. Piksel kayması bir tamsayı olduğundan, cvRect'u oluşturmak için bir tamsayı değerine sahip olmanız gerekir. rowindex'u tutmayı ve artırmayı ve cvRect yapıcısında kullanmadan hemen önce fraksiyon olarak adım atmayı ve int dönüşümü öneririm - bu şekilde, endeksiniz mümkün olduğunca eşit olarak hareket edecektir.

   Float-to-int dönüşümünde yuvarlama değeri bir int'e çok yakın olduğunda (umarım) yuvarlama hatalarından kaçınmak için bir epsilon değeri kullandığımı unutmayın. Bir örnek ve tekniğin bir açıklaması için bkz. this blog post and comments. Ancak, kodun test edilmediğini ve özellikle de int değerleriniz büyükse yuvarlama hataları olabileceğini unutmayın!

   /* To see how these calculations work out, experiment with 
       roiw == 8, StepRow == 4 and frameWidth == 14, 15, 16, 17 */ 
   /* N.B.: Does not cover the case when frameWidth < roiw! */ 
   int stepRowCount = (frameWidth - roiw + (StepRow - 1))/StepRow + 1; 
   float step = ((float)(frameWidth - roiw))/(stepRowCount - 1); 
   float eps = 0.005; 
   
   for (float rowindex = 0.0; (int)(rowindex + eps) <= frameWidth - roiw; rowindex += StepRow) 
   /* ... column loop ... */ 
       { searchRect = cvRect((int)(rowindex + eps), colindex, roiw, roih); 
   

PS: Bir 1920x1080 görüntüsünde size 1080p gibi 1920 sütun ve 1080 satır (dolayısıyla terimleri beri resim genişliği dolaşır senin endeksi colIndex ve bunun tersi olarak adlandırılan olmamalı)?