static void
vl_hog_prepare_buffers (VlHog * self, vl_size width, vl_size height, vl_size cellSize)
{
vl_size hogWidth = (width + cellSize/2) / cellSize ;
vl_size hogHeight = (height + cellSize/2) / cellSize ;
assert(width > 3) ;
assert(height > 3) ;
assert(hogWidth > 0) ;
assert(hogHeight > 0) ;
if (self->hog &&
self->hogWidth == hogWidth &&
self->hogHeight == hogHeight) {
/* a suitable buffer is already allocated */
memset(self->hog, 0, sizeof(float) * hogWidth * hogHeight * self->numOrientations * 2) ;
memset(self->hogNorm, 0, sizeof(float) * hogWidth * hogHeight) ;
return ;
}
if (self->hog) {
vl_free(self->hog) ;
self->hog = NULL ;
}
if (self->hogNorm) {
vl_free(self->hogNorm) ;
self->hogNorm = NULL ;
}
self->hog = vl_calloc(hogWidth * hogHeight * self->numOrientations * 2, sizeof(float)) ;
self->hogNorm = vl_calloc(hogWidth * hogHeight, sizeof(float)) ;
self->hogWidth = hogWidth ;
self->hogHeight = hogHeight ;
}
VlKDForestSearcher *
vl_kdforest_new_searcher (VlKDForest * kdforest)
{
VlKDForestSearcher * self = vl_calloc(sizeof(VlKDForestSearcher), 1);
self->forest = kdforest;
self->searchHeapArray = vl_malloc (sizeof(VlKDForestSearchState) * kdforest->maxNumNodes) ;
self->searchIdBook = vl_calloc (sizeof(vl_uindex), kdforest->numData) ;
return self ;
}
VlIKMFilt *
vl_ikm_new (int method)
{
VlIKMFilt *f = vl_calloc (sizeof(VlIKMFilt), 1) ;
f -> method = method ;
f -> max_niters = 200 ;
return f ;
}
/** -------------------------------------------------------------------
** @brief Create a new MSER filter
**
** Initializes a new MSER filter for images of the specified
** dimensions. Images are @a ndims -dimensional arrays of dimensions
** @a dims.
**
** @param ndims number of dimensions.
** @param dims dimensions.
**/
VL_EXPORT
VlMserFilt*
vl_mser_new (int ndims, int const* dims)
{
VlMserFilt* f ;
int *strides, k ;
f = vl_calloc (sizeof(VlMserFilt), 1) ;
f-> ndims = ndims ;
f-> dims = vl_malloc (sizeof(int) * ndims) ;
f-> subs = vl_malloc (sizeof(int) * ndims) ;
f-> dsubs = vl_malloc (sizeof(int) * ndims) ;
f-> strides = vl_malloc (sizeof(int) * ndims) ;
/* shortcuts */
strides = f-> strides ;
/* copy dims to f->dims */
for(k = 0 ; k < ndims ; ++k) {
f-> dims [k] = dims [k] ;
}
/* compute strides to move into the N-dimensional image array */
strides [0] = 1 ;
for(k = 1 ; k < ndims ; ++k) {
strides [k] = strides [k-1] * dims [k-1] ;
}
/* total number of pixels */
f-> nel = strides [ndims-1] * dims [ndims-1] ;
/* dof of ellipsoids */
f-> dof = ndims * (ndims + 1) / 2 + ndims ;
/* more buffers */
f-> perm = vl_malloc (sizeof(vl_uint) * f-> nel) ;
f-> joins = vl_malloc (sizeof(vl_uint) * f-> nel) ;
f-> r = vl_malloc (sizeof(VlMserReg) * f-> nel) ;
f-> er = 0 ;
f-> rer = 0 ;
f-> mer = 0 ;
f-> rmer = 0 ;
f-> ell = 0 ;
f-> rell = 0 ;
/* other parameters */
f-> delta = 5 ;
f-> max_area = 0.75 ;
f-> min_area = 3.0 / f-> nel ;
f-> max_variation = 0.25 ;
f-> min_diversity = 0.2 ;
return f ;
}
VL_EXPORT
VlQS *
vl_quickshift_new(vl_qs_type const * image, int height, int width,
int channels)
{
VlQS * q = vl_malloc(sizeof(VlQS));
q->image = (vl_qs_type *)image;
q->height = height;
q->width = width;
q->channels = channels;
q->medoid = VL_FALSE;
q->tau = VL_MAX(height,width)/50;
q->sigma = VL_MAX(2, q->tau/3);
q->dists = vl_calloc(height*width, sizeof(vl_qs_type));
q->parents = vl_calloc(height*width, sizeof(int));
q->density = vl_calloc(height*width, sizeof(vl_qs_type)) ;
return q;
}
VlScaleSpace *
vl_scalespace_new_with_geometry (VlScaleSpaceGeometry geom)
{
vl_index o ;
vl_size numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;
vl_size numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
VlScaleSpace *self ;
assert(is_valid_geometry(geom)) ;
numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;
self = vl_calloc(1, sizeof(VlScaleSpace)) ;
if (self == NULL) goto err_alloc_self ;
self->geom = geom ;
self->octaves = vl_calloc(numOctaves, sizeof(float*)) ;
if (self->octaves == NULL) goto err_alloc_octave_list ;
for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
vl_size octaveSize = ogeom.width * ogeom.height * numSublevels ;
self->octaves[o - self->geom.firstOctave] = vl_malloc(octaveSize * sizeof(float)) ;
if (self->octaves[o - self->geom.firstOctave] == NULL) goto err_alloc_octaves;
}
return self ;
err_alloc_octaves:
for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
if (self->octaves[o - self->geom.firstOctave]) {
vl_free(self->octaves[o - self->geom.firstOctave]) ;
}
}
err_alloc_octave_list:
vl_free(self) ;
err_alloc_self:
return NULL ;
}
void
vl_svmdataset_set_homogeneous_kernel_map (VlSvmDataset * self,
VlHomogeneousKernelMap * hom)
{
assert(self) ;
self->hom = hom ;
self->homDimension = 0 ;
if (self->homBuffer) {
vl_free (self->homBuffer) ;
self->homBuffer = 0 ;
}
if (self->hom) {
self->homDimension = vl_homogeneouskernelmap_get_dimension(self->hom) ;
self->homBuffer = vl_calloc(self->homDimension, vl_get_type_size(self->dataType)) ;
}
}
VlSvmDataset*
vl_svmdataset_new (vl_type dataType, void *data, vl_size dimension, vl_size numData)
{
VlSvmDataset * self ;
assert(dataType == VL_TYPE_DOUBLE || dataType == VL_TYPE_FLOAT) ;
assert(data) ;
self = vl_calloc(1, sizeof(VlSvmDataset)) ;
if (self == NULL) return NULL ;
self->dataType = dataType ;
self->data = data ;
self->dimension = dimension ;
self->numData = numData ;
self->hom = NULL ;
self->homBuffer = NULL ;
return self ;
}
VlKDForest *
vl_kdforest_new (vl_type dataType,
vl_size dimension, vl_size numTrees, VlVectorComparisonType distance)
{
VlKDForest * self = vl_calloc (sizeof(VlKDForest), 1) ;
assert(dataType == VL_TYPE_FLOAT || dataType == VL_TYPE_DOUBLE) ;
assert(dimension >= 1) ;
assert(numTrees >= 1) ;
self -> rand = vl_get_rand () ;
self -> dataType = dataType ;
self -> numData = 0 ;
self -> data = 0 ;
self -> dimension = dimension ;
self -> numTrees = numTrees ;
self -> trees = 0 ;
self -> thresholdingMethod = VL_KDTREE_MEDIAN ;
self -> splitHeapSize = VL_MIN(numTrees, VL_KDTREE_SPLIT_HEAP_SIZE) ;
self -> splitHeapNumNodes = 0 ;
self -> distance = distance;
self -> maxNumNodes = 0 ;
switch (self->dataType) {
case VL_TYPE_FLOAT:
self -> distanceFunction = (void(*)(void))
vl_get_vector_comparison_function_f (distance) ;
break;
case VL_TYPE_DOUBLE :
self -> distanceFunction = (void(*)(void))
vl_get_vector_comparison_function_d (distance) ;
break ;
default :
abort() ;
}
return self ;
}
VL_EXPORT vl_size
vl_kdforest_query (VlKDForest * self,
VlKDForestNeighbor * neighbors,
vl_size numNeighbors,
void const * query)
{
vl_uindex i, ti ;
vl_bool exactSearch = (self->searchMaxNumComparisons == 0) ;
VlKDForestSearchState * searchState ;
vl_size numAddedNeighbors = 0 ;
assert (neighbors) ;
assert (numNeighbors > 0) ;
assert (query) ;
/* this number is used to differentiate a query from the next */
self -> searchId += 1 ;
self -> searchNumRecursions = 0 ;
if (! self -> searchHeapArray) {
/* count number of tree nodes */
/* add support structures */
vl_size maxNumNodes = 0 ;
for (ti = 0 ; ti < self->numTrees ; ++ti) {
maxNumNodes += self->trees[ti]->numUsedNodes ;
}
self -> searchHeapArray = vl_malloc (sizeof(VlKDForestSearchState) * maxNumNodes) ;
self -> searchIdBook = vl_calloc (sizeof(vl_uindex), self->numData) ;
for (ti = 0 ; ti < self->numTrees ; ++ti) {
double * searchBounds = vl_malloc(sizeof(double) * 2 * self->dimension) ;
double * iter = searchBounds ;
double * end = iter + 2 * self->dimension ;
while (iter < end) {
*iter++ = - VL_INFINITY_F ;
*iter++ = + VL_INFINITY_F ;
}
vl_kdtree_calc_bounds_recursively (self->trees[ti], 0, searchBounds) ;
vl_free (searchBounds) ;
}
}
self->searchNumComparisons = 0 ;
self->searchNumSimplifications = 0 ;
/* put the root node into the search heap */
self->searchHeapNumNodes = 0 ;
for (ti = 0 ; ti < self->numTrees ; ++ ti) {
searchState = self->searchHeapArray + self->searchHeapNumNodes ;
searchState -> tree = self->trees[ti] ;
searchState -> nodeIndex = 0 ;
searchState -> distanceLowerBound = 0 ;
vl_kdforest_search_heap_push (self->searchHeapArray, &self->searchHeapNumNodes) ;
}
/* branch and bound */
while (exactSearch || self->searchNumComparisons < self->searchMaxNumComparisons)
{
/* pop the next optimal search node */
VlKDForestSearchState * searchState ;
/* break if search space completed */
if (self->searchHeapNumNodes == 0) {
break ;
}
searchState = self->searchHeapArray +
vl_kdforest_search_heap_pop (self->searchHeapArray, &self->searchHeapNumNodes) ;
/* break if no better solution may exist */
if (numAddedNeighbors == numNeighbors &&
neighbors[0].distance < searchState->distanceLowerBound) {
self->searchNumSimplifications ++ ;
break ;
}
vl_kdforest_query_recursively (self,
searchState->tree,
searchState->nodeIndex,
neighbors,
numNeighbors,
&numAddedNeighbors,
searchState->distanceLowerBound,
query) ;
}
/* sort neighbors by increasing distance */
for (i = numAddedNeighbors ; i < numNeighbors ; ++ i) {
neighbors[i].index = -1 ;
neighbors[i].distance = VL_NAN_F ;
}
while (numAddedNeighbors) {
vl_kdforest_neighbor_heap_pop (neighbors, &numAddedNeighbors) ;
}
return self->searchNumComparisons ;
}
VL_EXPORT
void vl_quickshift_process(VlQS * q)
{
vl_qs_type const *I = q->image;
int *parents = q->parents;
vl_qs_type *E = q->density;
vl_qs_type *dists = q->dists;
vl_qs_type *M = 0, *n = 0 ;
vl_qs_type sigma = q->sigma ;
vl_qs_type tau = q->tau;
vl_qs_type tau2 = tau*tau;
int K = q->channels, d;
int N1 = q->height, N2 = q->width;
int i1,i2, j1,j2, R, tR;
d = 2 + K ; /* Total dimensions include spatial component (x,y) */
if (q->medoid) { /* n and M are only used in mediod shift */
M = (vl_qs_type *) vl_calloc(N1*N2*d, sizeof(vl_qs_type)) ;
n = (vl_qs_type *) vl_calloc(N1*N2, sizeof(vl_qs_type)) ;
}
R = (int) ceil (3 * sigma) ;
tR = (int) ceil (tau) ;
/* -----------------------------------------------------------------
* n
* -------------------------------------------------------------- */
/* If we are doing medoid shift, initialize n to the inner product of the
* image with itself
*/
if (n) {
for (i2 = 0 ; i2 < N2 ; ++ i2) {
for (i1 = 0 ; i1 < N1 ; ++ i1) {
n [i1 + N1 * i2] = vl_quickshift_inner(I,N1,N2,K,
i1,i2,
i1,i2) ;
}
}
}
/* -----------------------------------------------------------------
* E = - [oN'*F]', M
* -------------------------------------------------------------- */
/*
D_ij = d(x_i,x_j)
E_ij = exp(- .5 * D_ij / sigma^2) ;
F_ij = - E_ij
E_i = sum_j E_ij
M_di = sum_j X_j F_ij
E is the parzen window estimate of the density
0 = dissimilar to everything, windowsize = identical
*/
for (i2 = 0 ; i2 < N2 ; ++ i2) {
for (i1 = 0 ; i1 < N1 ; ++ i1) {
int j1min = VL_MAX(i1 - R, 0 ) ;
int j1max = VL_MIN(i1 + R, N1-1) ;
int j2min = VL_MAX(i2 - R, 0 ) ;
int j2max = VL_MIN(i2 + R, N2-1) ;
/* For each pixel in the window compute the distance between it and the
* source pixel */
for (j2 = j2min ; j2 <= j2max ; ++ j2) {
for (j1 = j1min ; j1 <= j1max ; ++ j1) {
vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
/* Make distance a similarity */
vl_qs_type Fij = - exp(- Dij / (2*sigma*sigma)) ;
/* E is E_i above */
E [i1 + N1 * i2] -= Fij ;
if (M) {
/* Accumulate votes for the median */
int k ;
M [i1 + N1*i2 + (N1*N2) * 0] += j1 * Fij ;
M [i1 + N1*i2 + (N1*N2) * 1] += j2 * Fij ;
for (k = 0 ; k < K ; ++k) {
M [i1 + N1*i2 + (N1*N2) * (k+2)] +=
I [j1 + N1*j2 + (N1*N2) * k] * Fij ;
}
}
} /* j1 */
} /* j2 */
} /* i1 */
} /* i2 */
/* -----------------------------------------------------------------
* Find best neighbors
* -------------------------------------------------------------- */
if (q->medoid) {
/*
Qij = - nj Ei - 2 sum_k Gjk Mik
n is I.^2
*/
/* medoid shift */
for (i2 = 0 ; i2 < N2 ; ++i2) {
for (i1 = 0 ; i1 < N1 ; ++i1) {
vl_qs_type sc_best = 0 ;
/* j1/j2 best are the best indicies for each i */
vl_qs_type j1_best = i1 ;
vl_qs_type j2_best = i2 ;
int j1min = VL_MAX(i1 - R, 0 ) ;
int j1max = VL_MIN(i1 + R, N1-1) ;
int j2min = VL_MAX(i2 - R, 0 ) ;
int j2max = VL_MIN(i2 + R, N2-1) ;
for (j2 = j2min ; j2 <= j2max ; ++ j2) {
for (j1 = j1min ; j1 <= j1max ; ++ j1) {
vl_qs_type Qij = - n [j1 + j2 * N1] * E [i1 + i2 * N1] ;
int k ;
Qij -= 2 * j1 * M [i1 + i2 * N1 + (N1*N2) * 0] ;
Qij -= 2 * j2 * M [i1 + i2 * N1 + (N1*N2) * 1] ;
for (k = 0 ; k < K ; ++k) {
Qij -= 2 *
I [j1 + j2 * N1 + (N1*N2) * k] *
M [i1 + i2 * N1 + (N1*N2) * (k + 2)] ;
}
if (Qij > sc_best) {
sc_best = Qij ;
j1_best = j1 ;
j2_best = j2 ;
}
}
}
/* parents_i is the linear index of j which is the best pair
* dists_i is the score of the best match
*/
parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
dists[i1 + N1 * i2] = sc_best ;
}
}
} else {
/* Quickshift assigns each i to the closest j which has an increase in the
* density (E). If there is no j s.t. Ej > Ei, then dists_i == inf (a root
* node in one of the trees of merges).
*/
for (i2 = 0 ; i2 < N2 ; ++i2) {
for (i1 = 0 ; i1 < N1 ; ++i1) {
vl_qs_type E0 = E [i1 + N1 * i2] ;
vl_qs_type d_best = VL_QS_INF ;
vl_qs_type j1_best = i1 ;
vl_qs_type j2_best = i2 ;
int j1min = VL_MAX(i1 - tR, 0 ) ;
int j1max = VL_MIN(i1 + tR, N1-1) ;
int j2min = VL_MAX(i2 - tR, 0 ) ;
int j2max = VL_MIN(i2 + tR, N2-1) ;
for (j2 = j2min ; j2 <= j2max ; ++ j2) {
for (j1 = j1min ; j1 <= j1max ; ++ j1) {
if (E [j1 + N1 * j2] > E0) {
vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
if (Dij <= tau2 && Dij < d_best) {
d_best = Dij ;
j1_best = j1 ;
j2_best = j2 ;
}
}
}
}
/* parents is the index of the best pair */
/* dists_i is the minimal distance, inf implies no Ej > Ei within
* distance tau from the point */
parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
dists[i1 + N1 * i2] = sqrt(d_best) ;
}
}
}
if (M) vl_free(M) ;
if (n) vl_free(n) ;
}
VlLiopDesc *
r3d_vl_liopdesc_new (vl_int numNeighbours, vl_int numSpatialBins,
float radius, vl_size sideLength)
{
vl_index i, t ;
VlLiopDesc * self = vl_calloc(sizeof(VlLiopDesc), 1);
assert(radius <= sideLength/2) ;
self->numNeighbours = numNeighbours ;
self->numSpatialBins = numSpatialBins ;
self->neighRadius = radius ;
self->intensityThreshold = DEFAULT_INTENSITY_THRESHOLD ;
self->dimension = factorial(numNeighbours) * numSpatialBins ;
/*
Precompute a list of pixels within a circular patch inside
the square image. Leave a suitable marging for sampling around
these pixels.
*/
self->patchSize = 0 ;
self->patchPixels = vl_malloc(sizeof(vl_uindex)*sideLength*sideLength) ;
self->patchSideLength = sideLength ;
{
vl_index x, y ;
vl_index center = (sideLength - 1) / 2 ;
double t = center - radius + 0.6 ;
vl_index t2 = (vl_index) (t * t) ;
for (y = 0 ; y < (signed)sideLength ; ++y) {
for (x = 0 ; x < (signed)sideLength ; ++x) {
vl_index dx = x - center ;
vl_index dy = y - center ;
if (x == 0 && y == 0) continue ;
if (dx*dx + dy*dy <= t2) {
self->patchPixels[self->patchSize++] = x + y * sideLength ;
}
}
}
}
self->patchIntensities = vl_malloc(sizeof(vl_uindex)*self->patchSize) ;
self->patchPermutation = vl_malloc(sizeof(vl_uindex)*self->patchSize) ;
/*
Precompute the samples in the circular neighbourhood of each
measurement point.
*/
self->neighPermutation = vl_malloc(sizeof(vl_uindex) * self->numNeighbours) ;
self->neighIntensities = vl_malloc(sizeof(float) * self->numNeighbours) ;
self->neighSamplesX = vl_calloc(sizeof(double), self->numNeighbours * self->patchSize) ;
self->neighSamplesY = vl_calloc(sizeof(double), self->numNeighbours * self->patchSize) ;
for (i = 0 ; i < (signed)self->patchSize ; ++i) {
vl_index pixel ;
double x, y ;
double dangle = 2*VL_PI / (double)self->numNeighbours ;
double angle0 ;
vl_index center = (sideLength - 1) / 2 ;
pixel = self->patchPixels[i] ;
x = (pixel % (signed)self->patchSideLength) - center ;
y = (pixel / (signed)self->patchSideLength) - center ;
angle0 = atan2(y,x) ;
for (t = 0 ; t < (signed)self->numNeighbours ; ++t) {
double x1 = x + radius * cos(angle0 + dangle * t) + center ;
double y1 = y + radius * sin(angle0 + dangle * t) + center ;
self->neighSamplesX[t + (signed)self->numNeighbours * i] = x1 ;
self->neighSamplesY[t + (signed)self->numNeighbours * i] = y1 ;
}
}
return self ;
}
void
vl_slic_segment (vl_uint32 * segmentation,
float const * image,
vl_size width,
vl_size height,
vl_size numChannels,
vl_size regionSize,
float regularization,
vl_size minRegionSize)
{
vl_index i, x, y, u, v, k, region ;
vl_uindex iter ;
vl_size const numRegionsX = (vl_size) ceil((double) width / regionSize) ;
vl_size const numRegionsY = (vl_size) ceil((double) height / regionSize) ;
vl_size const numRegions = numRegionsX * numRegionsY ;
vl_size const numPixels = width * height ;
float * centers ;
float * edgeMap ;
float previousEnergy = VL_INFINITY_F ;
float startingEnergy ;
vl_uint32 * masses ;
vl_size const maxNumIterations = 100 ;
assert(segmentation) ;
assert(image) ;
assert(width >= 1) ;
assert(height >= 1) ;
assert(numChannels >= 1) ;
assert(regionSize >= 1) ;
assert(regularization >= 0) ;
#define atimage(x,y,k) image[(x)+(y)*width+(k)*width*height]
#define atEdgeMap(x,y) edgeMap[(x)+(y)*width]
edgeMap = vl_calloc(numPixels, sizeof(float)) ;
masses = vl_malloc(sizeof(vl_uint32) * numPixels) ;
centers = vl_malloc(sizeof(float) * (2 + numChannels) * numRegions) ;
/* compute edge map (gradient strength) */
for (k = 0 ; k < (signed)numChannels ; ++k) {
for (y = 1 ; y < (signed)height-1 ; ++y) {
for (x = 1 ; x < (signed)width-1 ; ++x) {
float a = atimage(x-1,y,k) ;
float b = atimage(x+1,y,k) ;
float c = atimage(x,y+1,k) ;
float d = atimage(x,y-1,k) ;
atEdgeMap(x,y) += (a - b) * (a - b) + (c - d) * (c - d) ;
}
}
}
/* initialize K-means centers */
i = 0 ;
for (v = 0 ; v < (signed)numRegionsY ; ++v) {
for (u = 0 ; u < (signed)numRegionsX ; ++u) {
vl_index xp ;
vl_index yp ;
vl_index centerx = 0 ;
vl_index centery = 0 ;
float minEdgeValue = VL_INFINITY_F ;
x = (vl_index) vl_round_d(regionSize * (u + 0.5)) ;
y = (vl_index) vl_round_d(regionSize * (v + 0.5)) ;
x = VL_MAX(VL_MIN(x, (signed)width-1),0) ;
y = VL_MAX(VL_MIN(y, (signed)height-1),0) ;
/* search in a 3x3 neighbourhood the smallest edge response */
for (yp = VL_MAX(0, y-1) ; yp <= VL_MIN((signed)height-1, y+1) ; ++ yp) {
for (xp = VL_MAX(0, x-1) ; xp <= VL_MIN((signed)width-1, x+1) ; ++ xp) {
float thisEdgeValue = atEdgeMap(xp,yp) ;
if (thisEdgeValue < minEdgeValue) {
minEdgeValue = thisEdgeValue ;
centerx = xp ;
centery = yp ;
}
}
}
/* initialize the new center at this location */
centers[i++] = (float) centerx ;
centers[i++] = (float) centery ;
for (k = 0 ; k < (signed)numChannels ; ++k) {
centers[i++] = atimage(centerx,centery,k) ;
}
}
}
/* run k-means iterations */
for (iter = 0 ; iter < maxNumIterations ; ++iter) {
float factor = regularization / (regionSize * regionSize) ;
float energy = 0 ;
/* assign pixels to centers */
for (y = 0 ; y < (signed)height ; ++y) {
for (x = 0 ; x < (signed)width ; ++x) {
vl_index u = floor((double)x / regionSize - 0.5) ;
vl_index v = floor((double)y / regionSize - 0.5) ;
vl_index up, vp ;
float minDistance = VL_INFINITY_F ;
for (vp = VL_MAX(0, v) ; vp <= VL_MIN((signed)numRegionsY-1, v+1) ; ++vp) {
for (up = VL_MAX(0, u) ; up <= VL_MIN((signed)numRegionsX-1, u+1) ; ++up) {
vl_index region = up + vp * numRegionsX ;
float centerx = centers[(2 + numChannels) * region + 0] ;
float centery = centers[(2 + numChannels) * region + 1] ;
float spatial = (x - centerx) * (x - centerx) + (y - centery) * (y - centery) ;
float appearance = 0 ;
float distance ;
for (k = 0 ; k < (signed)numChannels ; ++k) {
float centerz = centers[(2 + numChannels) * region + k + 2] ;
float z = atimage(x,y,k) ;
appearance += (z - centerz) * (z - centerz) ;
}
distance = appearance + factor * spatial ;
if (minDistance > distance) {
minDistance = distance ;
segmentation[x + y * width] = (vl_uint32)region ;
}
}
}
energy += minDistance ;
}
}
/*
VL_PRINTF("vl:slic: iter %d: energy: %g\n", iter, energy) ;
*/
/* check energy termination conditions */
if (iter == 0) {
startingEnergy = energy ;
} else {
if ((previousEnergy - energy) < 1e-5 * (startingEnergy - energy)) {
break ;
}
}
previousEnergy = energy ;
/* recompute centers */
memset(masses, 0, sizeof(vl_uint32) * width * height) ;
memset(centers, 0, sizeof(float) * (2 + numChannels) * numRegions) ;
for (y = 0 ; y < (signed)height ; ++y) {
for (x = 0 ; x < (signed)width ; ++x) {
vl_index pixel = x + y * width ;
vl_index region = segmentation[pixel] ;
masses[region] ++ ;
centers[region * (2 + numChannels) + 0] += x ;
centers[region * (2 + numChannels) + 1] += y ;
for (k = 0 ; k < (signed)numChannels ; ++k) {
centers[region * (2 + numChannels) + k + 2] += atimage(x,y,k) ;
}
}
}
for (region = 0 ; region < (signed)numRegions ; ++region) {
float mass = VL_MAX(masses[region], 1e-8) ;
for (i = (2 + numChannels) * region ;
i < (signed)(2 + numChannels) * (region + 1) ;
++i) {
centers[i] /= mass ;
}
}
}
vl_free(masses) ;
vl_free(centers) ;
vl_free(edgeMap) ;
/* elimiate small regions */
{
vl_uint32 * cleaned = vl_calloc(numPixels, sizeof(vl_uint32)) ;
vl_uindex * segment = vl_malloc(sizeof(vl_uindex) * numPixels) ;
vl_size segmentSize ;
vl_uint32 label ;
vl_uint32 cleanedLabel ;
vl_size numExpanded ;
vl_index const dx [] = {+1, -1, 0, 0} ;
vl_index const dy [] = { 0, 0, +1, -1} ;
vl_index direction ;
vl_index pixel ;
for (pixel = 0 ; pixel < (signed)numPixels ; ++pixel) {
if (cleaned[pixel]) continue ;
label = segmentation[pixel] ;
numExpanded = 0 ;
segmentSize = 0 ;
segment[segmentSize++] = pixel ;
/*
find cleanedLabel as the label of an already cleaned
region neighbor of this pixel
*/
cleanedLabel = label + 1 ;
cleaned[pixel] = label + 1 ;
x = pixel % width ;
y = pixel / width ;
for (direction = 0 ; direction < 4 ; ++direction) {
vl_index xp = x + dx[direction] ;
vl_index yp = y + dy[direction] ;
vl_index neighbor = xp + yp * width ;
if (0 <= xp && xp < (signed)width &&
0 <= yp && yp < (signed)height &&
cleaned[neighbor]) {
cleanedLabel = cleaned[neighbor] ;
}
}
/* expand the segment */
while (numExpanded < segmentSize) {
vl_index open = segment[numExpanded++] ;
x = open % width ;
y = open / width ;
for (direction = 0 ; direction < 4 ; ++direction) {
vl_index xp = x + dx[direction] ;
vl_index yp = y + dy[direction] ;
vl_index neighbor = xp + yp * width ;
if (0 <= xp && xp < (signed)width &&
0 <= yp && yp < (signed)height &&
cleaned[neighbor] == 0 &&
segmentation[neighbor] == label) {
cleaned[neighbor] = label + 1 ;
segment[segmentSize++] = neighbor ;
}
}
}
/* change label to cleanedLabel if the segment is too small */
if (segmentSize < minRegionSize) {
while (segmentSize > 0) {
cleaned[segment[--segmentSize]] = cleanedLabel ;
}
}
}
/* restore base 0 indexing of the regions */
for (pixel = 0 ; pixel < (signed)numPixels ; ++pixel) cleaned[pixel] -- ;
memcpy(segmentation, cleaned, numPixels * sizeof(vl_uint32)) ;
vl_free(cleaned) ;
vl_free(segment) ;
}
}
VlHog *
vl_hog_new (VlHogVariant variant, vl_size numOrientations, vl_bool transposed)
{
vl_index o, k ;
VlHog * self = vl_calloc(1, sizeof(VlHog)) ;
assert(numOrientations >= 1) ;
self->variant = variant ;
self->numOrientations = numOrientations ;
self->glyphSize = 21 ;
self->transposed = transposed ;
self->useBilinearOrientationAssigment = VL_FALSE ;
self->orientationX = vl_malloc(sizeof(float) * self->numOrientations) ;
self->orientationY = vl_malloc(sizeof(float) * self->numOrientations) ;
/*
Create a vector along the center of each orientation bin. These
are used to map gradients to bins. If the image is transposed,
then this can be adjusted here by swapping X and Y in these
vectors.
*/
for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
double angle = o * VL_PI / self->numOrientations ;
if (!self->transposed) {
self->orientationX[o] = (float) cos(angle) ;
self->orientationY[o] = (float) sin(angle) ;
} else {
self->orientationX[o] = (float) sin(angle) ;
self->orientationY[o] = (float) cos(angle) ;
}
}
/*
If the number of orientation is equal to 9, one gets:
Uoccti:: 18 directed orientations + 9 undirected orientations + 4 texture
DalalTriggs:: 9 undirected orientations x 4 blocks.
*/
switch (self->variant) {
case VlHogVariantUoctti:
self->dimension = 3*self->numOrientations + 4 ;
break ;
case VlHogVariantDalalTriggs:
self->dimension = 4*self->numOrientations ;
break ;
default:
assert(0) ;
}
/*
A permutation specifies how to permute elements in a HOG
descriptor to flip it horizontally. Since the first orientation
of index 0 points to the right, this must be swapped with orientation
self->numOrientation that points to the left (for the directed case,
and to itself for the undirected one).
*/
self->permutation = vl_malloc(self->dimension * sizeof(vl_index)) ;
switch (self->variant) {
case VlHogVariantUoctti:
for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
vl_index op = self->numOrientations - o ;
self->permutation[o] = op ;
self->permutation[o + self->numOrientations] = (op + self->numOrientations) % (2*self->numOrientations) ;
self->permutation[o + 2*self->numOrientations] = (op % self->numOrientations) + 2*self->numOrientations ;
}
for (k = 0 ; k < 4 ; ++k) {
/* The texture features correspond to four displaced block around
a cell. These permute with a lr flip as for DalalTriggs. */
vl_index blockx = k % 2 ;
vl_index blocky = k / 2 ;
vl_index q = (1 - blockx) + blocky * 2 ;
self->permutation[k + self->numOrientations * 3] = q + self->numOrientations * 3 ;
}
break ;
case VlHogVariantDalalTriggs:
for(k = 0 ; k < 4 ; ++k) {
/* Find the corresponding block. Blocks are listed in order 1,2,3,4,...
from left to right and top to bottom */
vl_index blockx = k % 2 ;
vl_index blocky = k / 2 ;
vl_index q = (1 - blockx) + blocky * 2 ;
for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
vl_index op = self->numOrientations - o ;
self->permutation[o + k*self->numOrientations] = (op % self->numOrientations) + q*self->numOrientations ;
}
}
break ;
default:
assert(0) ;
}
/*
Create glyphs for representing the HOG features/ filters. The glyphs
are simple bars, oriented orthogonally to the gradients to represent
image edges. If the object is configured to work on transposed image,
the glyphs images are also stored in column-major.
*/
self->glyphs = vl_calloc(self->glyphSize * self->glyphSize * self->numOrientations, sizeof(float)) ;
#define atglyph(x,y,k) self->glyphs[(x) + self->glyphSize * (y) + self->glyphSize * self->glyphSize * (k)]
for (o = 0 ; o < (signed)self->numOrientations ; ++o) {
double angle = fmod(o * VL_PI / self->numOrientations + VL_PI/2, VL_PI) ;
double x2 = self->glyphSize * cos(angle) / 2 ;
double y2 = self->glyphSize * sin(angle) / 2 ;
if (angle <= VL_PI / 4 || angle >= VL_PI * 3 / 4) {
/* along horizontal direction */
double slope = y2 / x2 ;
double offset = (1 - slope) * (self->glyphSize - 1) / 2 ;
vl_index skip = (1 - fabs(cos(angle))) / 2 * self->glyphSize ;
vl_index i, j ;
for (i = skip ; i < (signed)self->glyphSize - skip ; ++i) {
j = vl_round_d(slope * i + offset) ;
if (! self->transposed) {
atglyph(i,j,o) = 1 ;
} else {
atglyph(j,i,o) = 1 ;
}
}
} else {
/* along vertical direction */
double slope = x2 / y2 ;
double offset = (1 - slope) * (self->glyphSize - 1) / 2 ;
vl_index skip = (1 - sin(angle)) / 2 * self->glyphSize ;
vl_index i, j ;
for (j = skip ; j < (signed)self->glyphSize - skip; ++j) {
i = vl_round_d(slope * j + offset) ;
if (! self->transposed) {
atglyph(i,j,o) = 1 ;
} else {
atglyph(j,i,o) = 1 ;
}
}
}
}
return self ;
}
vl_size
vl_kdforest_query_with_array (VlKDForest * self,
vl_uint32 * indexes,
vl_size numNeighbors,
vl_size numQueries,
void * distances,
void const * queries)
{
vl_size numComparisons = 0;
vl_type dataType = vl_kdforest_get_data_type(self) ;
vl_size dimension = vl_kdforest_get_data_dimension(self) ;
#ifdef _OPENMP
#pragma omp parallel default(shared) num_threads(vl_get_max_threads())
#endif
{
vl_index qi ;
vl_size thisNumComparisons = 0 ;
VlKDForestSearcher * searcher ;
VlKDForestNeighbor * neighbors ;
#ifdef _OPENMP
#pragma omp critical
#endif
{
searcher = vl_kdforest_new_searcher(self) ;
neighbors = vl_calloc (sizeof(VlKDForestNeighbor), numNeighbors) ;
}
#ifdef _OPENMP
#pragma omp for
#endif
for(qi = 0 ; qi < (signed)numQueries; ++ qi) {
switch (dataType) {
case VL_TYPE_FLOAT: {
vl_size ni;
thisNumComparisons += vl_kdforestsearcher_query (searcher, neighbors, numNeighbors,
(float const *) (queries) + qi * dimension) ;
for (ni = 0 ; ni < numNeighbors ; ++ni) {
indexes [qi*numNeighbors + ni] = (vl_uint32) neighbors[ni].index ;
if (distances){
*((float*)distances + qi*numNeighbors + ni) = neighbors[ni].distance ;
}
}
break ;
}
case VL_TYPE_DOUBLE: {
vl_size ni;
thisNumComparisons += vl_kdforestsearcher_query (searcher, neighbors, numNeighbors,
(double const *) (queries) + qi * dimension) ;
for (ni = 0 ; ni < numNeighbors ; ++ni) {
indexes [qi*numNeighbors + ni] = (vl_uint32) neighbors[ni].index ;
if (distances){
*((double*)distances + qi*numNeighbors + ni) = neighbors[ni].distance ;
}
}
break ;
}
default:
abort() ;
}
}
#ifdef _OPENMP
#pragma omp critical
#endif
{
numComparisons += thisNumComparisons ;
vl_kdforestsearcher_delete (searcher) ;
vl_free (neighbors) ;
}
}
return numComparisons ;
}
