void ProcessImage::ProcessSaveRes(Image &image, vector<REAL>&r,
vector<REAL>& g, vector<REAL>& b, const string&ofile) {// Work on each color channel RGB
if (gamma == 1 && !dog)
ReadImage(image, r, g, b);
if (gamma != 1)// Perform the gamma normalization of the image...
// image magick gamma is x=y^(1/gamma); so sending
// 1/gamma leads to x=y^gamma;
// to have tip style normalization...
{
image.gamma(1 / gamma);
if (!dog)
ReadImage(image, r, g, b);
}
if (dog) {
// Now using ImageMagick Implementation for padding
UINT k2size = ceil(k2 * 3);
Image image2 = image;
// 3 to include 3 sigma bell
image.blur(ceil(k1 * 3), k1);// applies separable filters...
image2.blur(k2size, k2);
SubtractImage(image, image2, r, g, b);
}
WriteImageFile(ofile + "_dog", r, g, b, image.rows(), image.columns());
if (constr || coneq) {
REAL imgstat[6];
ExtractChannelStats(r, g, b, imgstat);
if (constr)
DoContrastStretching(r, g, b, imgstat);
if (coneq)
DoContrastEqualization(r, g, b, imgstat);
}
}
void ProcessImage::ProcessGray(Image &image, vector<REAL>&des1) {
REAL imgstat[2];
if (gamma == 1 && !dog)
ReadImage(image, des1);
if (gamma != 1)// Perform the gamma normalization of the image...
{
image.gamma(1 / gamma);
if (!dog) {
ReadImage(image, des1);
}
}
if (dog) {
// Now using ImageMagick Implementation for padding
UINT k2size = ceil(k2 * 3);
Image image2 = image;
// 2 to include 2 sigma bell
image.blur(ceil(k1 * 3), k1);// applies separable filters...
image2.blur(k2size, k2);
SubtractImage(image, image2, des1);
}
if (constr || coneq) {
REAL imgstat[2];
ExtractChannelStats(des1, imgstat);
if (constr)
DoContrastStretching(des1, imgstat);
if (coneq)
DoContrastEqualization(des1, imgstat);
}
}
/* Find keypoints within one octave of scale space starting with the
given image. The octSize parameter gives the size of each pixel
relative to the input image. Returns new list of keypoints after
adding to the existing list "keys".
*/
KKeypoint OctaveKeypoints(Image image, Image *pnextImage, float octSize,
KKeypoint keys)
{
int i;
float sigmaRatio, prevSigma, increase;
Image blur[Scales+3], dogs[Scales+2];
/* Ratio of each scale to the previous one. The parameter Scales
determines how many scales we divide the octave into, so
sigmaRatio ** Scales = 2.0.
*/
sigmaRatio = pow(2.0, 1.0 / (float) Scales);
/* Build array "blur", holding Scales+3 blurred versions of the image. */
blur[0] = image; /* First level is input to this routine. */
prevSigma = InitSigma; /* Input image has InitSigma smoothing. */
/* Form each level by adding incremental blur from previous level.
Increase in blur is from prevSigma to prevSigma * sigmaRatio, so
increase**2 + prevSigma**2 = (prevSigma * sigmaRatio)**2
*/
for (i = 1; i < Scales + 3; i++) {
blur[i] = CopyImage(blur[i-1], IMAGE_POOL);
increase = prevSigma * sqrt(sigmaRatio * sigmaRatio - 1.0);
GaussianBlur(blur[i], increase);
prevSigma *= sigmaRatio;
}
/* Compute an array, dogs, of difference-of-Gaussian images by
subtracting each image from its next blurred version.
*/
for (i = 0; i < Scales + 2; i++) {
dogs[i] = CopyImage(blur[i], IMAGE_POOL);
SubtractImage(dogs[i], blur[i+1]);
}
/* Image blur[Scales] has twice the blur of starting image for
this octave, so it is returned to downsample for next octave.
*/
*pnextImage = blur[Scales];
return FindMaxMin(dogs, blur, octSize, keys);
}
