Initial Commit
Had to recreate repo because it was corrupted. FML.
This commit is contained in:
Mark Hoekveen
+406
@@ -0,0 +1,406 @@
|
||||
#pragma once
|
||||
#include <string>
|
||||
#include <boost/filesystem.hpp>
|
||||
#include <Magick++.h>
|
||||
|
||||
#include <bitset> //in which we store our feature vectors
|
||||
#include <algorithm> //for sorting
|
||||
|
||||
using namespace std;
|
||||
using namespace Magick;
|
||||
|
||||
namespace fs = boost::filesystem;
|
||||
|
||||
//Virtual base class
|
||||
//Holds definitions for all common functions of descriptors,
|
||||
//but should be overloaded by a child class
|
||||
class Descriptor {
|
||||
public:
|
||||
virtual bitset<64> feature(Image* img) = 0;
|
||||
|
||||
//Interpret the bitsets as integers and calculate their distance.
|
||||
virtual unsigned long long distance(bitset<64> a, bitset<64> b) {
|
||||
return abs(((long long)a.to_ullong() - (long long)b.to_ullong()));
|
||||
};
|
||||
virtual string ToString() = 0;
|
||||
virtual fs::path ToPath() {
|
||||
return fs::path(this->ToString());
|
||||
}
|
||||
|
||||
//should return true if a > b
|
||||
virtual bool bigger(bitset<64> a, bitset<64> b) {
|
||||
return true;
|
||||
}
|
||||
|
||||
double* CalculateDCT(Image* img) {
|
||||
double pi = 3.14159265359;
|
||||
img->type(GrayscaleType);
|
||||
img->filterType(LanczosFilter); //fast!
|
||||
img->resize(Geometry(8, 8)); //64 pixels
|
||||
ssize_t n = 8;
|
||||
ssize_t m = 8;
|
||||
Pixels view(*img);
|
||||
int numpixels = (int)(n*m);
|
||||
int chan = (int)img->channels(); //should be 1, just intensity
|
||||
const Quantum *p = view.getConst(0, 0, n, m); //entire image
|
||||
bitset<64> retval(0);
|
||||
int N = n*m;
|
||||
Image* newimg = new Image(Geometry(n, m), Color("white"));
|
||||
newimg->type(GrayscaleType);
|
||||
Pixels conview(*newimg);
|
||||
Quantum *c = conview.get(0, 0, n, m); //entire converted image
|
||||
|
||||
double converted[64];
|
||||
double* q = converted;
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
double sum = 0;
|
||||
int k = (j*m) + i;
|
||||
const Quantum *p_s = view.getConst(0, 0, n, m); //entire image
|
||||
for (ssize_t x = 0; x < m; x++) {
|
||||
for (ssize_t y = 0; y < n; y++) {
|
||||
int n = (x*m) + y;
|
||||
double pixel = ((double)p_s[0] / QuantumRange); //rescaled from 0 to 1
|
||||
//cout << "pixel: " << pixel << endl;
|
||||
sum += pixel * std::cos((pi / N)*(n + 0.5)*k);
|
||||
p_s = p_s + chan;
|
||||
}
|
||||
}
|
||||
q[0] = sum;
|
||||
/*if (p[0] != 0)
|
||||
retval |= bitset<64>(1); //XOR
|
||||
retval <<= 1;*/
|
||||
q = q++;
|
||||
p = p + chan;
|
||||
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 64; i++) {
|
||||
c[0] = converted[i] * 255.0;
|
||||
c++;
|
||||
}
|
||||
newimg->write("Out.png");
|
||||
return converted;
|
||||
}
|
||||
};
|
||||
|
||||
//Average color of the image.
|
||||
//the least significant 24 bits of the feature represent
|
||||
//the color intensity of the average color in RGB
|
||||
//with 8 bits per color.
|
||||
class averageColor : public Descriptor {
|
||||
public:
|
||||
bitset<64> feature(Image* img) {
|
||||
ssize_t n = img->columns();
|
||||
ssize_t m = img->rows();
|
||||
Pixels view(*img);
|
||||
const Quantum *p = view.getConst(0, 0, n, m); //entire image
|
||||
unsigned long long red = 0, green = 0, blue = 0;
|
||||
float numpixels = (float)(n*m);
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
//LTR scanning
|
||||
red += p[0];
|
||||
green += p[1];
|
||||
blue += p[2];
|
||||
p = p + 3;
|
||||
}
|
||||
}
|
||||
//get the color values.. implicit cast to int
|
||||
int r = ((red/numpixels) / QuantumRange) * 255;
|
||||
int g = ((green/numpixels) / QuantumRange) * 255;
|
||||
int b = ((blue/numpixels) / QuantumRange) * 255;
|
||||
//now store all this into a bitset.. assuming 8 bits per color, if everything went correctly.. which we should check.. probably..
|
||||
bitset<64> retval(r);
|
||||
retval <<= 8;
|
||||
retval |= bitset<64>(g);
|
||||
retval <<= 8;
|
||||
retval |= bitset<64>(b);
|
||||
return retval;
|
||||
}
|
||||
unsigned long long distance(bitset<64> a, bitset<64> b) {
|
||||
//do some bit shifting magic to get ints back
|
||||
int red_a = (a >> 16).to_ulong();
|
||||
int green_a = (a << (64-16) >> (64-8)).to_ulong();
|
||||
int blue_a = (a << (64-8) >> (64-8)).to_ulong();
|
||||
int red_b = (b >> 16).to_ulong();
|
||||
int green_b = (b << (64 - 16) >> (64 - 8)).to_ulong();
|
||||
int blue_b = (b << (64 - 8) >> (64 - 8)).to_ulong();
|
||||
return abs(red_a - red_b) + abs(green_a - green_b) + abs(blue_a - blue_b);
|
||||
};
|
||||
string ToString() {
|
||||
return "averageColor";
|
||||
}
|
||||
};
|
||||
|
||||
//Counts the total number of colors
|
||||
//and stores it in bit representation.
|
||||
//Upper limit 16777216
|
||||
//Only uses least significant 24 bits
|
||||
class numColors : public Descriptor {
|
||||
public:
|
||||
bitset<64> feature(Image* img) {
|
||||
return bitset<64>(img->totalColors()-1);
|
||||
}
|
||||
string ToString() {
|
||||
return "numColors";
|
||||
}
|
||||
};
|
||||
|
||||
//Median descriptor. See relevant literature.
|
||||
//Stores a map of the image (LTR scanned) with 1 iff
|
||||
//higher than median and 0 otherwise.
|
||||
class median : public Descriptor {
|
||||
public:
|
||||
bitset<64> feature(Image* img) {
|
||||
img->type(GrayscaleType);
|
||||
img->filterType(LanczosFilter); //fast resizing, should have minimal impact on accuracy
|
||||
img->resize(Geometry(8, 8, 0, 0)); //64 pixels
|
||||
ssize_t n = 8;
|
||||
ssize_t m = 8;
|
||||
Pixels view(*img);
|
||||
float intensity = 0;
|
||||
int numpixels = (int)(n*m);
|
||||
|
||||
const Quantum *p = view.getConst(0, 0, n, m); //entire image
|
||||
int* intensities = new int[numpixels];
|
||||
int index = 0;
|
||||
int chan = (int)img->channels(); //should be 1, for a grayscale img
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
//LTR scanning
|
||||
intensities[index] = p[0];
|
||||
p = p + chan;
|
||||
index++;
|
||||
}
|
||||
}
|
||||
//Calculate median:
|
||||
sort(intensities, intensities + numpixels);
|
||||
//We know where the median is going to be:
|
||||
intensity = (float)(intensities[31] + intensities[32]) / 2;
|
||||
bitset<64> retval(0);
|
||||
const Quantum *q = view.getConst(0, 0, n, m); //entire image
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
retval <<= 1;
|
||||
if (q[0] > intensity)
|
||||
retval |= bitset<64>(1);
|
||||
q = q + img->channels();
|
||||
}
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
//biterror
|
||||
unsigned long long distance(bitset<64> a, bitset<64> b) {
|
||||
int biterror = 0;
|
||||
for (int i = 0; i < 64; i++) {
|
||||
if (a[i] != b[i]) biterror++;
|
||||
}
|
||||
return biterror;
|
||||
}
|
||||
string ToString() {
|
||||
return "median";
|
||||
}
|
||||
};
|
||||
|
||||
//Sobel descriptor
|
||||
//Calculates average intensity of the image with
|
||||
//sobel convolution applied in both directions
|
||||
class sobel : public Descriptor {
|
||||
public:
|
||||
bitset<64> feature(Image* img) {
|
||||
//TODO: Some preprocessing for this?
|
||||
//img->reduceNoise(4.0);
|
||||
img->type(GrayscaleType);
|
||||
|
||||
//Apply sobel convolution
|
||||
img->convolve(3, sobelX);
|
||||
img->convolve(3, sobelY);
|
||||
|
||||
ssize_t n = img->rows();
|
||||
ssize_t m = img->columns();
|
||||
|
||||
Pixels view(*img);
|
||||
const Quantum *p = view.getConst(0, 0, m, n); //entire image
|
||||
unsigned long long intensity = 0;
|
||||
int chan = (int)img->channels();
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
//LTR scanning
|
||||
intensity += p[0];
|
||||
//cout << p[0] << " ";
|
||||
p = p + chan;
|
||||
}
|
||||
//cout << endl;
|
||||
}
|
||||
int scaledIntensity = ((float)(intensity / (n*m)) / QuantumRange) * 255;
|
||||
return bitset<64>(scaledIntensity);
|
||||
}
|
||||
string ToString() {
|
||||
return "sobel";
|
||||
}
|
||||
private:
|
||||
const double sobelX[9] = { 1, 0, -1, 2, 0, -2, 1, 0, -1 };
|
||||
const double sobelY[9] = { 1, 2, 1, 0, 0, 0, -1, -2, -1 };
|
||||
};
|
||||
|
||||
//Peason code
|
||||
//Creates a map of the 8*8 image which has 1
|
||||
//iff the pixel is higher than the next pixel,
|
||||
//0 otherwise
|
||||
class pearson : public Descriptor {
|
||||
public:
|
||||
bitset<64> feature(Image* img) {
|
||||
img->type(GrayscaleType);
|
||||
img->filterType(LanczosFilter); //fast!
|
||||
img->resize(Geometry(8, 8)); //64 pixels
|
||||
ssize_t n = 8;
|
||||
ssize_t m = 8;
|
||||
Pixels view(*img);
|
||||
int intensity = 0;
|
||||
int numpixels = (int)(n*m);
|
||||
int chan = (int)img->channels();
|
||||
const Quantum *p = view.getConst(0, 0, n, m); //entire image
|
||||
bitset<64> retval(0);
|
||||
int prev = p[0]; //so we always start with a 0
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
//LTR scanning
|
||||
//NOTE: Scanning order might be quite relevant for this descriptor
|
||||
int cur = p[0];
|
||||
if(prev < cur) retval |= bitset<64>(1); //XOR
|
||||
prev = cur;
|
||||
|
||||
p = p + chan;
|
||||
retval <<= 1;
|
||||
}
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
unsigned long long distance(bitset<64> a, bitset<64> b) {
|
||||
int biterror = 0;
|
||||
for (int i = 0; i < 64; i++) {
|
||||
if (a[i] != b[i]) biterror++;
|
||||
}
|
||||
return biterror;
|
||||
};
|
||||
string ToString() {
|
||||
return "pearson";
|
||||
}
|
||||
};
|
||||
|
||||
//Uses an adaptive thresholding algorithm on an 8*8
|
||||
//images. Re-calculates the threshold for each 2*2
|
||||
//neighbourhood and stores it in a LTR map
|
||||
class threshold : public Descriptor {
|
||||
public:
|
||||
bitset<64> feature(Image* img) {
|
||||
img->type(GrayscaleType);
|
||||
img->filterType(LanczosFilter); //fast!
|
||||
img->resize(Geometry(8, 8)); //64 pixels
|
||||
img->adaptiveThreshold(2, 2); //Thresholding in a moving 2*2 neighborhood
|
||||
ssize_t n = 8;
|
||||
ssize_t m = 8;
|
||||
Pixels view(*img);
|
||||
int numpixels = (int)(n*m);
|
||||
int chan = (int)img->channels();
|
||||
const Quantum *p = view.getConst(0, 0, n, m); //entire image
|
||||
bitset<64> retval(0);
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
//LTR scanning
|
||||
//cout << p[0] << " ";
|
||||
if(p[0] != 0)
|
||||
retval |= bitset<64>(1); //XOR
|
||||
retval <<= 1;
|
||||
p = p + chan;
|
||||
|
||||
}
|
||||
//cout << endl;
|
||||
}
|
||||
//cout << "----" << endl << endl;
|
||||
return retval;
|
||||
}
|
||||
unsigned long long distance(bitset<64> a, bitset<64> b) {
|
||||
int biterror = 0;
|
||||
for (int i = 0; i < 64; i++) {
|
||||
if (a[i] != b[i]) biterror++;
|
||||
}
|
||||
return biterror;
|
||||
};
|
||||
string ToString() {
|
||||
return "threshold";
|
||||
}
|
||||
};
|
||||
|
||||
//Uses an adaptive thresholding algorithm on an 8*8
|
||||
//images. Re-calculates the threshold for each 2*2
|
||||
//neighbourhood and stores it in a LTR map
|
||||
class DCTPearson: public Descriptor {
|
||||
public:
|
||||
bitset<64> feature(Image* img) {
|
||||
img->type(GrayscaleType);
|
||||
img->filterType(LanczosFilter); //fast!
|
||||
img->resize(Geometry(8, 8)); //64 pixels
|
||||
ssize_t n = 8;
|
||||
ssize_t m = 8;
|
||||
Pixels view(*img);
|
||||
int numpixels = (int)(n*m);
|
||||
int chan = (int)img->channels(); //should be 1, just intensity
|
||||
const Quantum *p = view.getConst(0, 0, n, m); //entire image
|
||||
bitset<64> retval(0);
|
||||
int N = n*m;
|
||||
/*Image* converted = new Image(Geometry(n, m), Color("white"));
|
||||
Pixels conview(*converted);
|
||||
const Quantum *q = conview.getConst(0, 0, n, m); //entire converted image*/
|
||||
|
||||
double* converted = CalculateDCT(img);
|
||||
/*double* q = converted;
|
||||
for (ssize_t j = 0; j < m; j++) {
|
||||
for (ssize_t i = 0; i < n; i++) {
|
||||
double sum = 0;
|
||||
int k = (j*m) + i;
|
||||
const Quantum *p_s = view.getConst(0, 0, n, m); //entire image
|
||||
for (ssize_t x = 0; x < m; x++) {
|
||||
for (ssize_t y = 0; y < n; y++) {
|
||||
int n = (x*m) + y;
|
||||
double pixel = ((double)p_s[0] / QuantumRange); //rescaled from 0 to 1
|
||||
//cout << "pixel: " << pixel << endl;
|
||||
sum += pixel * std::cos((pi/N)*(n+0.5)*k);
|
||||
p_s = p_s + chan;
|
||||
}
|
||||
}
|
||||
q[0] = sum;
|
||||
q = q++;
|
||||
p = p + chan;
|
||||
|
||||
}
|
||||
//cout << endl;
|
||||
}*/
|
||||
double prev = 0;
|
||||
for (int i = 0; i < 64; i++) {
|
||||
if (converted[i] > prev) {
|
||||
retval |= bitset<64>(1); //XOR
|
||||
//cout << "1";
|
||||
}
|
||||
//else cout << "0";
|
||||
retval <<= 1;
|
||||
prev = converted[i];
|
||||
}
|
||||
//cout << "----" << endl << endl;
|
||||
return retval;
|
||||
}
|
||||
unsigned long long distance(bitset<64> a, bitset<64> b) {
|
||||
int biterror = 0;
|
||||
for (int i = 0; i < 64; i++) {
|
||||
if (a[i] != b[i]) biterror++;
|
||||
}
|
||||
return biterror;
|
||||
};
|
||||
string ToString() {
|
||||
return "Discrete Cosine Transform";
|
||||
}
|
||||
private:
|
||||
double pi = 3.14159265359;
|
||||
};
|
||||
Reference in New Issue
Block a user