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 ;
}
