/usr/include/vigra/gaborfilter.hxx is in libvigraimpex-dev 1.10.0+dfsg-3ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 | /************************************************************************/
/* */
/* Copyright 2002-2004 by Ullrich Koethe and Hans Meine */
/* */
/* This file is part of the VIGRA computer vision library. */
/* The VIGRA Website is */
/* http://hci.iwr.uni-heidelberg.de/vigra/ */
/* Please direct questions, bug reports, and contributions to */
/* ullrich.koethe@iwr.uni-heidelberg.de or */
/* vigra@informatik.uni-hamburg.de */
/* */
/* Permission is hereby granted, free of charge, to any person */
/* obtaining a copy of this software and associated documentation */
/* files (the "Software"), to deal in the Software without */
/* restriction, including without limitation the rights to use, */
/* copy, modify, merge, publish, distribute, sublicense, and/or */
/* sell copies of the Software, and to permit persons to whom the */
/* Software is furnished to do so, subject to the following */
/* conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the */
/* Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
/* OTHER DEALINGS IN THE SOFTWARE. */
/* */
/************************************************************************/
#ifndef VIGRA_GABORFILTER_HXX
#define VIGRA_GABORFILTER_HXX
#include "imagecontainer.hxx"
#include "config.hxx"
#include "stdimage.hxx"
#include "copyimage.hxx"
#include "transformimage.hxx"
#include "combineimages.hxx"
#include "utilities.hxx"
#include "multi_shape.hxx"
#include <functional>
#include <vector>
#include <cmath>
namespace vigra {
/** \addtogroup GaborFilter Gabor Filter
Functions to create or apply gabor filter (latter based on FFTW).
*/
//@{
/********************************************************/
/* */
/* createGaborFilter */
/* */
/********************************************************/
/** \brief Create a gabor filter in frequency space.
The orientation is given in radians, the other parameters are the
center frequency (for example 0.375 or smaller) and the two
angular and radial sigmas of the gabor filter. (See \ref
angularGaborSigma() for an explanation of possible values.)
The energy of the filter is explicitly normalized to 1.0.
<b> Declarations:</b>
pass 2D array views:
\code
namespace vigra {
template <class T, class S>
void
createGaborFilter(MultiArrayView<2, T, S> dest,
double orientation, double centerFrequency,
double angularSigma, double radialSigma);
}
\endcode
\deprecatedAPI{createGaborFilter}
pass \ref ImageIterators and \ref DataAccessors :
\code
namespace vigra {
template <class DestImageIterator, class DestAccessor>
void createGaborFilter(DestImageIterator destUpperLeft,
DestImageIterator destLowerRight,
DestAccessor da,
double orientation, double centerFrequency,
double angularSigma, double radialSigma)
}
\endcode
use argument objects in conjunction with \ref ArgumentObjectFactories :
\code
namespace vigra {
template <class DestImageIterator, class DestAccessor>
void createGaborFilter(triple<DestImageIterator,
DestImageIterator,
DestAccessor> dest,
double orientation, double centerFrequency,
double angularSigma, double radialSigma)
}
\endcode
\deprecatedEnd
<b> Usage:</b>
<b>\#include</b> \<vigra/gaborfilter.hxx\><br/>
Namespace: vigra
\code
MultiArray<2, float> gabor(w,h);
createGaborFilter(gabor, orient, freq,
angularGaborSigma(directionCount, freq),
radialGaborSigma(freq));
\endcode
\deprecatedUsage{createGaborFilter}
\code
vigra::FImage gabor(w,h);
vigra::createGaborFilter(destImageRange(gabor), orient, freq,
angularGaborSigma(directionCount, freq),
radialGaborSigma(freq));
\endcode
\deprecatedEnd
*/
doxygen_overloaded_function(template <...> void createGaborFilter)
template <class DestImageIterator, class DestAccessor>
void createGaborFilter(DestImageIterator destUpperLeft,
DestImageIterator destLowerRight, DestAccessor da,
double orientation, double centerFrequency,
double angularSigma, double radialSigma)
{
int w = int(destLowerRight.x - destUpperLeft.x);
int h = int(destLowerRight.y - destUpperLeft.y);
double squaredSum = 0.0;
double cosTheta= VIGRA_CSTD::cos(orientation);
double sinTheta= VIGRA_CSTD::sin(orientation);
double radialSigma2 = radialSigma*radialSigma;
double angularSigma2 = angularSigma*angularSigma;
double wscale = w % 1 ?
1.0f / (w-1) :
1.0f / w;
double hscale = h % 1 ?
1.0f / (h-1) :
1.0f / h;
int dcX= (w+1)/2, dcY= (h+1)/2;
double u, v;
for ( int y=0; y<h; y++, destUpperLeft.y++ )
{
typename DestImageIterator::row_iterator dix = destUpperLeft.rowIterator();
v = hscale * ((h - (y - dcY))%h - dcY);
for ( int x=0; x<w; x++, dix++ )
{
u= wscale*((x - dcX + w)%w - dcX);
double uu = cosTheta*u + sinTheta*v - centerFrequency;
double vv = -sinTheta*u + cosTheta*v;
double gabor;
gabor = VIGRA_CSTD::exp(-0.5*(uu*uu / radialSigma2 + vv*vv / angularSigma2));
squaredSum += gabor * gabor;
da.set( gabor, dix );
}
}
destUpperLeft.y -= h;
// clear out DC value and remove it from the squared sum
double dcValue = da(destUpperLeft);
squaredSum -= dcValue * dcValue;
da.set( 0.0, destUpperLeft );
// normalize energy to one
double factor = VIGRA_CSTD::sqrt(squaredSum);
for ( int y=0; y<h; y++, destUpperLeft.y++ )
{
typename DestImageIterator::row_iterator dix = destUpperLeft.rowIterator();
for ( int x=0; x<w; x++, dix++ )
{
da.set( da(dix) / factor, dix );
}
}
}
template <class DestImageIterator, class DestAccessor>
inline void
createGaborFilter(triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
double orientation, double centerFrequency,
double angularSigma, double radialSigma)
{
createGaborFilter(dest.first, dest.second, dest.third,
orientation, centerFrequency,
angularSigma, radialSigma);
}
template <class T, class S>
inline void
createGaborFilter(MultiArrayView<2, T, S> dest,
double orientation, double centerFrequency,
double angularSigma, double radialSigma)
{
createGaborFilter(destImageRange(dest),
orientation, centerFrequency,
angularSigma, radialSigma);
}
/********************************************************/
/* */
/* radialGaborSigma */
/* */
/********************************************************/
/** \brief Calculate sensible radial sigma for given parameters.
For a brief introduction what is meant with "sensible" sigmas, see
\ref angularGaborSigma().
<b> Declaration:</b>
\code
namespace vigra {
double radialGaborSigma(double centerFrequency)
}
\endcode
*/
inline double radialGaborSigma(double centerFrequency)
{
double sfactor = 3.0 * VIGRA_CSTD::sqrt(VIGRA_CSTD::log(4.0));
return centerFrequency / sfactor;
}
/********************************************************/
/* */
/* angularGaborSigma */
/* */
/********************************************************/
/** \brief Calculate sensible angular sigma for given parameters.
"Sensible" means: If you use a range of gabor filters for feature
detection, you are interested in minimal redundancy. This is hard
to define but one possible try is to arrange the filters in
frequency space, so that the half-peak-magnitude ellipses touch
each other.
To do so, you must know the number of directions (first parameter
for the angular sigma function) and the center frequency of the
filter you want to calculate the sigmas for.
The exact formulas are:
\code
sigma_radial= 1/sqrt(ln(4)) * centerFrequency/3
\endcode
\code
sigma_angular= 1/sqrt(ln(4)) * tan(pi/(directions*2))
* sqrt(8/9) * centerFrequency
\endcode
<b> Declaration:</b>
\code
namespace vigra {
double angularGaborSigma(int directionCount, double centerFrequency)
}
\endcode
*/
inline double angularGaborSigma(int directionCount, double centerFrequency)
{
return VIGRA_CSTD::tan(M_PI/directionCount/2.0) * centerFrequency
* VIGRA_CSTD::sqrt(8.0 / (9 * VIGRA_CSTD::log(4.0)));
}
/********************************************************/
/* */
/* GaborFilterFamily */
/* */
/********************************************************/
/** \brief Family of gabor filters of different scale and direction.
A GaborFilterFamily can be used to quickly create a whole family
of gabor filters in frequency space. Especially useful in
conjunction with \ref applyFourierFilterFamily, since it's derived
from \ref ImageArray.
The filter parameters are chosen to make the center frequencies
decrease in octaves with increasing scale indices, and to make the
half-peak-magnitude ellipses touch each other to somewhat reduce
redundancy in the filter answers. This is done by using \ref
angularGaborSigma() and \ref radialGaborSigma(), you'll find more
information there.
The template parameter ImageType should be a scalar image type suitable for filling in
<b>\#include</b> \<vigra/gaborfilter.hxx\><br/>
Namespace: vigra
*/
template <class ImageType,
class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
class GaborFilterFamily
: public ImageArray<ImageType, Alloc>
{
typedef ImageArray<ImageType, Alloc> ParentClass;
int scaleCount_, directionCount_;
double maxCenterFrequency_;
protected:
void initFilters()
{
for(int direction= 0; direction<directionCount_; direction++)
for(int scale= 0; scale<scaleCount_; scale++)
{
double angle = direction * M_PI / directionCount();
double centerFrequency =
maxCenterFrequency_ / VIGRA_CSTD::pow(2.0, (double)scale);
createGaborFilter(destImageRange(this->images_[filterIndex(direction, scale)]),
angle, centerFrequency,
angularGaborSigma(directionCount(), centerFrequency),
radialGaborSigma(centerFrequency));
}
}
public:
enum { stdFilterSize= 128, stdDirectionCount= 6, stdScaleCount= 4 };
/** Constructs a family of gabor filters in frequency
space. The filters will be calculated on construction, so
it makes sense to provide good parameters right now
although they can be changed later, too. If you leave them
out, the defaults are a \ref directionCount of 6, a \ref
scaleCount of 4 and a \ref maxCenterFrequency of
3/8(=0.375).
*/
GaborFilterFamily(const Diff2D & size,
int directionCount = stdDirectionCount, int scaleCount = stdScaleCount,
double maxCenterFrequency = 3.0/8.0,
Alloc const & alloc = Alloc())
: ParentClass(directionCount*scaleCount, size, alloc),
scaleCount_(scaleCount),
directionCount_(directionCount),
maxCenterFrequency_(maxCenterFrequency)
{
initFilters();
}
/** Convenience variant of the above constructor taking width
and height separately. Also, this one serves as default
constructor constructing 128x128 pixel filters.
*/
GaborFilterFamily(int width= stdFilterSize, int height= -1,
int directionCount = stdDirectionCount, int scaleCount = stdScaleCount,
double maxCenterFrequency = 3.0/8.0,
Alloc const & alloc = Alloc())
: ParentClass(directionCount*scaleCount,
Size2D(width, height > 0 ? height : width), alloc),
scaleCount_(scaleCount),
directionCount_(directionCount),
maxCenterFrequency_(maxCenterFrequency)
{
initFilters();
}
/** Return the index of the filter with the given direction and
scale in this ImageArray. direction must in the range
0..directionCount()-1 and scale in the range
0..rangeCount()-1. This is useful for example if you used
\ref applyFourierFilterFamily() and got a resulting
ImageArray which still has the same order of images, but no
\ref getFilter() method anymore.
*/
int filterIndex(int direction, int scale) const
{
return scale*directionCount()+direction;
}
/** Return the filter with the given direction and
scale. direction must in the range 0..directionCount()-1
and scale in the range 0..rangeCount()-1.
<tt>filters.getFilter(direction, scale)</tt> is the same as
<tt>filters[filterIndex(direction, scale)]</tt>.
*/
ImageType const & getFilter(int direction, int scale) const
{
return this->images_[filterIndex(direction, scale)];
}
/** Resize all filters (causing their recalculation).
*/
virtual void resizeImages(const Diff2D &newSize)
{
ParentClass::resizeImages(newSize);
initFilters();
}
/** Query the number of filter scales available.
*/
int scaleCount() const
{ return scaleCount_; }
/** Query the number of filter directions available.
*/
int directionCount() const
{ return directionCount_; }
/** Change the number of directions / scales. This causes the
recalculation of all filters.
*/
void setDirectionScaleCounts(int directionCount, int scaleCount)
{
this->resize(directionCount * scaleCount);
scaleCount_ = scaleCount;
directionCount_ = directionCount;
initFilters();
}
/** Return the center frequency of the filter(s) with
scale==0. Filters with scale>0 will have a center frequency
reduced in octaves:
<tt>centerFrequency= maxCenterFrequency / 2.0^scale</tt>
*/
double maxCenterFrequency()
{ return maxCenterFrequency_; }
/** Change the center frequency of the filter(s) with
scale==0. See \ref maxCenterFrequency().
*/
void setMaxCenterFrequency(double maxCenterFrequency)
{
maxCenterFrequency_ = maxCenterFrequency;
initFilters();
}
};
//@}
} // namespace vigra
#endif // VIGRA_GABORFILTER_HXX
|