The Machine Perception Toolbox (MPT)

00199                                                                                                                                                                                                                 {
00200         
00201         double shift_tnew = lw_tnew.scale*shiftPct;
00202         if (shift_tnew < minStride) shift_tnew = minStride;
00203 
00204         double hrhyp = hr * lw_tnew.scale / shift_tnew;
00205   double cx_t = hx_t + (scale_t / 2);
00206   double cy_t = hy_t + (scale_t / 2);
00207   double x_tnew = cx_t - lw_tnew.scale/2;
00208   double y_tnew = cy_t - lw_tnew.scale/2;
00209   lw_tnew.x = x_tnew/shift_tnew - hrhyp;
00210   lw_tnew.y = y_tnew/shift_tnew - hrhyp;
00211 
00212   lw_tnew.x = floor(lw_tnew.x);
00213         lw_tnew.y = floor(lw_tnew.y);
00214         lw_tnew.size = floor (2*hrhyp + 1 + .5);
00215 
00216         if (lw_tnew.size < 1) lw_tnew.size = 1;
00217 
00218         /* make the window fit  -- must overlap at least one hypothesis */
00219         lw_tnew.x  = min(lw_tnew.x, numx-1);
00220         lw_tnew.y  = min(lw_tnew.y ,numy-1); 
00221         if ((lw_tnew.x + lw_tnew.size ) < 1) { /* move up until upper end is at least at 1. */
00222                 lw_tnew.x = 1-lw_tnew.size;
00223   }
00224         if ((lw_tnew.y + lw_tnew.size) < 1) { /* move up until upper end is at least at 1. */
00225                 lw_tnew.y = 1-lw_tnew.size;  
00226         }
00227 
00229         /* not sure if this is best way to do this -- turns even sized kernels into odd */
00230         if ( ((int)scale_t % 2 == 0) != ((int)lw_tnew.size % 2 == 0))
00231                 lw_tnew.size++;
00232 //      if (((int)(lw_tnew.size) % 2 == 0) &&
00233 //                      ((int)(scale_t) % 2 != 0))
00234 //              lw_tnew.size++;
00236 
00237         /* The derivation as written by John Hershey: 
00238                 h_t(s, i, j).x = i * shift
00239                 h_t(s, i, j).y = j * shift
00240 
00241                 c.x = h_t(s, i, j).x + s/2
00242                 c.y = h_t(s, i, j).y + s/2
00243 
00244                 x' = c.x - s'/2
00245                 y' = c.y - s'/2
00246 
00247                 i' = x'/shift'
00248                 j' = y'/shift'
00249 
00250                 hrhyp = hr * s' / shift'
00251 
00252                 box.i = i' - hrhyp
00253                 box.j = j' - hrhyp
00254                 box.s = 2*hrhyp
00255 
00256                         or
00257 
00258                 -hrhyp + (h_t(s,i,j).x + s/2 - s' / 2) / shift'
00259 
00260                 lw_tnew.x = -hrhyp + ((hx_t + scale_t/2 - lw_tnew.scale/2) / shift_tnew) ;
00261                 lw_tnew.y = -hrhyp + ((hy_t + scale_t/2 - lw_tnew.scale/2) / shift_tnew) ;
00262         */
00263 }


Public Member Functions
void	get_location_window (const double s, TBox< double > &lw, const double hr, const int hx, const int hy, const double shiftPct, const int minStride, const int numx, const int numy)
bool	is_validscale (const int scale)
bool	is_validscale (const double scale)
void	set_scalebounds (const int s)
void	set_scalebounds (const double s)
	UniformWindow (const int s, const int ns)
	UniformWindow (const double s)
Public Attributes
double	m_curhypscale
int	m_intscalebounddown
int	m_intscaleboundup
int	m_intscaledev
double	m_minstride
int	m_numscales
double	m_scalebounddown
double	m_scaleboundup
double	m_scaledev
double	m_shiftpct

The Machine Perception Toolbox

UniformWindow Struct Reference

Public Member Functions

Public Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation