Impala Documentation

template<int INDEX_SIZE, int ORI_SIZE>

void Impala::Core::Feature::FISTDescriptor< INDEX_SIZE, ORI_SIZE >::PutInVector	(	Real64 *	descriptor,
		Real64	mag,
		Real64	ori,
		Real64	rx,
		Real64	cx
	)			`[inline]`

Definition at line 66 of file KoenFIST2.h.

References Impala::Core::Feature::FISTDescriptor< INDEX_SIZE, ORI_SIZE >::CanonicalizeAngle(), and PI.

Referenced by Impala::Core::Feature::FISTDescriptor< INDEX_SIZE, ORI_SIZE >::InternalCount().

00068     {
00069         int ri, ci, oi;
00070         Real64 oval, rfrac, cfrac, ofrac;
00071        
00072         ori = CanonicalizeAngle(ori);
00073         oval = ORI_SIZE * ori / (2*(Real64)PI);
00074        
00075         ri = (int)floor(rx);
00076         ci = (int)floor(cx);
00077         oi = (int)floor(oval);
00078     
00079         // fractional parts of bin placement
00080         rfrac = rx - ri;
00081         cfrac = cx - ci;
00082         ofrac = oval - oi;
00083         if(!(rfrac >= 0.0 && rfrac <= 1.0 && cfrac >= 0.0 && cfrac <= 1.0 && ofrac >= 0.0 && ofrac <= 1.0))
00084         {
00085             std::cerr << "[Failure] Fractions outside valid range " << rfrac << " " << cfrac << " " << ofrac << std::endl;
00086             return;
00087         }
00088         if(oi >= ORI_SIZE) oi = 0;
00089     
00090         int rindex = ri;
00091         Real64 v;
00092         if((rindex >= 0) && (rindex < INDEX_SIZE))
00093         {
00094             int cindex = ci;
00095             if((cindex >= 0) && (cindex < INDEX_SIZE))
00096             {
00097                 // case 0
00098                 int oindex = oi;
00099                 v = mag * (1.0 - rfrac) * (1.0 - cfrac) * (1.0 - ofrac);
00100                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00101              
00102                 // case 1
00103                 oindex = oi + 1;
00104                 if(oindex >= ORI_SIZE) oindex = 0;
00105                 v = mag * (1.0 - rfrac) * (1.0 - cfrac) * ofrac;
00106                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00107             }
00108              
00109             cindex = ci + 1;
00110             if((cindex >= 0) && (cindex < INDEX_SIZE))
00111             {
00112                 // case 2
00113                 int oindex = oi;
00114                 v = mag * (1.0 - rfrac) * cfrac * (1.0 - ofrac);
00115                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00116              
00117                 // case 3
00118                 oindex = oi + 1;
00119                 if(oindex >= ORI_SIZE) oindex = 0;
00120                 v = mag * (1.0 - rfrac) * cfrac * ofrac;
00121                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00122             }
00123         }
00124         
00125         rindex = ri + 1;
00126         if((rindex >= 0) && (rindex < INDEX_SIZE))
00127         {
00128             int cindex = ci;
00129             if((cindex >= 0) && (cindex < INDEX_SIZE))
00130             {
00131                 // case 4
00132                 int oindex = oi;
00133                 v = mag * rfrac * (1.0 - cfrac) * (1.0 - ofrac);
00134                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00135              
00136                 // case 5
00137                 oindex = oi + 1;
00138                 if(oindex >= ORI_SIZE) oindex = 0;
00139                 v = mag * rfrac * (1.0 - cfrac) * ofrac;
00140                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00141             }
00142              
00143             cindex = ci + 1;
00144             if((cindex >= 0) && (cindex < INDEX_SIZE))
00145             {
00146                 // case 6
00147                 int oindex = oi;
00148                 v = mag * rfrac * cfrac * (1.0 - ofrac);
00149                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00150              
00151                 // case 7
00152                 oindex = oi + 1;
00153                 if(oindex >= ORI_SIZE) oindex = 0;
00154                 v = mag * rfrac * cfrac * ofrac;
00155                 descriptor[(rindex * INDEX_SIZE + cindex) * ORI_SIZE + oindex] += v;
00156             }
00157         }
00158     }

Here is the call graph for this function: