public static void assertEqualsRelative(ImageBase imgA, ImageBase imgB, double tolFrac) {
// if no specialized check exists, use a slower generalized approach
if (imgA instanceof ImageSingleBand) {
GImageSingleBand a = FactoryGImageSingleBand.wrap((ImageSingleBand) imgA);
GImageSingleBand b = FactoryGImageSingleBand.wrap((ImageSingleBand) imgB);
for (int y = 0; y < imgA.height; y++) {
for (int x = 0; x < imgA.width; x++) {
double valA = a.get(x, y).doubleValue();
double valB = b.get(x, y).doubleValue();
double difference = valA - valB;
double max = Math.max(Math.abs(valA), Math.abs(valB));
if (max == 0) max = 1;
if (Math.abs(difference) / max > tolFrac)
throw new RuntimeException(
"Values not equal at (" + x + "," + y + ") " + valA + " " + valB);
}
}
} else if (imgA instanceof MultiSpectral) {
MultiSpectral a = (MultiSpectral) imgA;
MultiSpectral b = (MultiSpectral) imgB;
if (a.getNumBands() != b.getNumBands())
throw new RuntimeException("Number of bands not equal");
for (int band = 0; band < a.getNumBands(); band++) {
assertEqualsRelative(a.getBand(band), b.getBand(band), tolFrac);
}
} else {
throw new RuntimeException("Unknown image type");
}
}
private void undoRadialDistortion(BufferedImage image) {
ConvertBufferedImage.convertFromMulti(image, origMS, true, ImageFloat32.class);
for (int i = 0; i < origMS.getNumBands(); i++) {
ImageFloat32 in = origMS.getBand(i);
ImageFloat32 out = correctedMS.getBand(i);
undoRadial.apply(in, out);
}
if (correctedMS.getNumBands() == 3)
ConvertBufferedImage.convertTo(correctedMS, undistorted, true);
else if (correctedMS.getNumBands() == 1)
ConvertBufferedImage.convertTo(correctedMS.getBand(0), undistorted);
else throw new RuntimeException("What kind of image has " + correctedMS.getNumBands() + "???");
}
@Override
public void setImage(MultiSpectral<T> image) {
gray.reshape(image.width, image.height);
grayII.reshape(image.width, image.height);
bandII.reshape(image.width, image.height);
GConvertImage.average(image, gray);
GIntegralImageOps.transform(gray, grayII);
for (int i = 0; i < image.getNumBands(); i++)
GIntegralImageOps.transform(image.getBand(i), bandII.getBand(i));
alg.setImage(grayII, bandII);
}
public static void assertEqualsInner(
ImageBase imgA, ImageBase imgB, double tol, int borderX, int borderY, boolean relative) {
// if no specialized check exists, use a slower generalized approach
if (imgA instanceof ImageSingleBand) {
GImageSingleBand a = FactoryGImageSingleBand.wrap((ImageSingleBand) imgA);
GImageSingleBand b = FactoryGImageSingleBand.wrap((ImageSingleBand) imgB);
for (int y = borderY; y < imgA.height - borderY; y++) {
for (int x = borderX; x < imgA.width - borderX; x++) {
double valA = a.get(x, y).doubleValue();
double valB = b.get(x, y).doubleValue();
double error = Math.abs(valA - valB);
if (relative) {
double denominator = Math.abs(valA) + Math.abs(valB);
if (denominator == 0) denominator = 1;
error /= denominator;
}
if (error > tol)
throw new RuntimeException(
"Values not equal at (" + x + "," + y + ") " + valA + " " + valB);
}
}
} else if (imgA instanceof MultiSpectral) {
MultiSpectral a = (MultiSpectral) imgA;
MultiSpectral b = (MultiSpectral) imgB;
if (a.getNumBands() != b.getNumBands())
throw new RuntimeException("Number of bands not equal");
for (int band = 0; band < a.getNumBands(); band++) {
assertEqualsInner(a.getBand(band), b.getBand(band), tol, borderX, borderY, relative);
}
} else {
throw new RuntimeException("Unknown image type");
}
}
public static void checkEquals(
BufferedImage imgA, MultiSpectral imgB, boolean boofcvBandOrder, float tol) {
if (imgA.getRaster() instanceof ByteInterleavedRaster
&& imgA.getType() != BufferedImage.TYPE_BYTE_INDEXED) {
ByteInterleavedRaster raster = (ByteInterleavedRaster) imgA.getRaster();
if (raster.getNumBands() == 1) {
GImageSingleBand band = FactoryGImageSingleBand.wrap(imgB.getBand(0));
int strideA = raster.getScanlineStride();
int offsetA = raster.getDataOffset(0) - raster.getPixelStride() + 1;
// handle a special case where the RGB conversion is screwed
for (int i = 0; i < imgA.getHeight(); i++) {
for (int j = 0; j < imgA.getWidth(); j++) {
double valB = band.get(j, i).doubleValue();
int valA = raster.getDataStorage()[offsetA + i * strideA + j];
valA &= 0xFF;
if (Math.abs(valA - valB) > tol)
throw new RuntimeException("Images are not equal: A = " + valA + " B = " + valB);
}
}
return;
}
}
int bandOrder[];
if (boofcvBandOrder) {
if (imgB.getNumBands() == 4) {
bandOrder = new int[] {1, 2, 3, 0};
} else {
bandOrder = new int[] {0, 1, 2};
}
} else {
if (imgA.getType() == BufferedImage.TYPE_INT_RGB) {
bandOrder = new int[] {0, 1, 2};
} else if (imgA.getType() == BufferedImage.TYPE_INT_BGR
|| imgA.getType() == BufferedImage.TYPE_3BYTE_BGR) {
bandOrder = new int[] {2, 1, 0};
} else if (imgA.getType() == BufferedImage.TYPE_4BYTE_ABGR) {
bandOrder = new int[] {0, 3, 2, 1};
} else if (imgA.getType() == BufferedImage.TYPE_INT_ARGB) {
bandOrder = new int[] {0, 1, 2, 3};
} else {
bandOrder = new int[] {0, 1, 2};
}
}
int expected[] = new int[4];
for (int y = 0; y < imgA.getHeight(); y++) {
for (int x = 0; x < imgA.getWidth(); x++) {
// getRGB() automatically converts the band order to ARGB
int rgb = imgA.getRGB(x, y);
expected[0] = ((rgb >>> 24) & 0xFF); // alpha
expected[1] = ((rgb >>> 16) & 0xFF); // red
expected[2] = ((rgb >>> 8) & 0xFF); // green
expected[3] = (rgb & 0xFF); // blue
if (imgB.getNumBands() == 4) {
for (int i = 0; i < 4; i++) {
double found = GeneralizedImageOps.get(imgB.getBand(bandOrder[i]), x, y);
if (Math.abs(Math.exp(expected[i] - found)) > tol) {
for (int j = 0; j < 4; j++) {
System.out.println(
expected[j] + " " + GeneralizedImageOps.get(imgB.getBand(bandOrder[j]), x, y));
}
throw new RuntimeException(
"Images are not equal: band - " + i + " type " + imgA.getType());
}
}
} else if (imgB.getNumBands() == 3) {
for (int i = 0; i < 3; i++) {
double found = GeneralizedImageOps.get(imgB.getBand(bandOrder[i]), x, y);
if (Math.abs(expected[i + 1] - found) > tol) {
for (int j = 0; j < 3; j++) {
System.out.println(
expected[j + 1]
+ " "
+ GeneralizedImageOps.get(imgB.getBand(bandOrder[j]), x, y));
}
throw new RuntimeException(
"Images are not equal: band - " + i + " type " + imgA.getType());
}
}
} else {
throw new RuntimeException("Unexpectd number of bands");
}
}
}
}
public static void checkEquals(WritableRaster imgA, MultiSpectral imgB, float tol) {
if (imgA.getNumBands() != imgB.getNumBands()) {
throw new RuntimeException("Number of bands not equals");
}
if (imgA instanceof ByteInterleavedRaster) {
ByteInterleavedRaster raster = (ByteInterleavedRaster) imgA;
byte dataA[] = raster.getDataStorage();
int strideA = raster.getScanlineStride();
int offsetA = raster.getDataOffset(0) - raster.getPixelStride() + 1;
// handle a special case where the RGB conversion is screwed
for (int y = 0; y < imgA.getHeight(); y++) {
int indexA = offsetA + strideA * y;
for (int x = 0; x < imgA.getWidth(); x++) {
for (int k = 0; k < imgB.getNumBands(); k++) {
int valueA = dataA[indexA++] & 0xFF;
double valueB = GeneralizedImageOps.get(imgB.getBand(k), x, y);
if (Math.abs(valueA - valueB) > tol)
throw new RuntimeException("Images are not equal: A = " + valueA + " B = " + valueB);
}
}
}
} else if (imgA instanceof IntegerInterleavedRaster) {
IntegerInterleavedRaster raster = (IntegerInterleavedRaster) imgA;
int dataA[] = raster.getDataStorage();
int strideA = raster.getScanlineStride();
int offsetA = raster.getDataOffset(0) - raster.getPixelStride() + 1;
// handle a special case where the RGB conversion is screwed
for (int y = 0; y < imgA.getHeight(); y++) {
int indexA = offsetA + strideA * y;
for (int x = 0; x < imgA.getWidth(); x++) {
int valueA = dataA[indexA++];
if (imgB.getNumBands() == 4) {
int found0 = (valueA >> 24) & 0xFF;
int found1 = (valueA >> 16) & 0xFF;
int found2 = (valueA >> 8) & 0xFF;
int found3 = valueA & 0xFF;
double expected0 = GeneralizedImageOps.get(imgB.getBand(0), x, y);
double expected1 = GeneralizedImageOps.get(imgB.getBand(1), x, y);
double expected2 = GeneralizedImageOps.get(imgB.getBand(2), x, y);
double expected3 = GeneralizedImageOps.get(imgB.getBand(3), x, y);
if (Math.abs(found0 - expected0) > tol)
throw new RuntimeException("Images are not equal");
if (Math.abs(found1 - expected1) > tol)
throw new RuntimeException("Images are not equal");
if (Math.abs(found2 - expected2) > tol)
throw new RuntimeException("Images are not equal");
if (Math.abs(found3 - expected3) > tol)
throw new RuntimeException("Images are not equal");
} else if (imgB.getNumBands() == 3) {
int found0 = (valueA >> 16) & 0xFF;
int found1 = (valueA >> 8) & 0xFF;
int found2 = valueA & 0xFF;
double expected0 = GeneralizedImageOps.get(imgB.getBand(0), x, y);
double expected1 = GeneralizedImageOps.get(imgB.getBand(1), x, y);
double expected2 = GeneralizedImageOps.get(imgB.getBand(2), x, y);
if (Math.abs(found0 - expected0) > tol)
throw new RuntimeException("Images are not equal");
if (Math.abs(found1 - expected1) > tol)
throw new RuntimeException("Images are not equal");
if (Math.abs(found2 - expected2) > tol)
throw new RuntimeException("Images are not equal");
} else {
throw new RuntimeException("Unexpectd number of bands");
}
}
}
} else {
throw new RuntimeException("Add support for raster type " + imgA.getClass().getSimpleName());
}
}
public <II extends ImageSingleBand> double[][] harder(BufferedImage image) {
MultiSpectral<ImageFloat32> colorImage =
ConvertBufferedImage.convertFromMulti(image, null, true, ImageFloat32.class);
// convert the color image to greyscale
ImageFloat32 greyscaleImage =
ConvertImage.average((MultiSpectral<ImageFloat32>) colorImage, null);
// SURF works off of integral images
Class<II> integralType = GIntegralImageOps.getIntegralType(ImageFloat32.class);
// define the feature detection algorithm
NonMaxSuppression extractor =
FactoryFeatureExtractor.nonmax(new ConfigExtract(2, detectThreshold, 5, true));
FastHessianFeatureDetector<II> detector =
new FastHessianFeatureDetector<II>(extractor, maxFeaturesPerScale, 2, 9, 4, 4);
// estimate orientation
OrientationIntegral<II> orientation = FactoryOrientationAlgs.sliding_ii(null, integralType);
DescribePointSurf<II> descriptor =
FactoryDescribePointAlgs.<II>surfStability(null, integralType);
// compute the integral image of the greyscale 'image'
II integralgrey =
GeneralizedImageOps.createSingleBand(
integralType, greyscaleImage.width, greyscaleImage.height);
GIntegralImageOps.transform(greyscaleImage, integralgrey);
// detect fast hessian features
detector.detect(integralgrey);
// === This is the point were the code starts deviating from the standard SURF! ===
// tell algorithms which image to process
orientation.setImage(integralgrey);
List<ScalePoint> points = detector.getFoundPoints();
double[][] descriptions = new double[points.size()][3 * descriptor.getDescriptionLength()];
double[] angles = new double[points.size()];
int l = 0;
for (ScalePoint p : points) {
orientation.setScale(p.scale);
angles[l] = orientation.compute(p.x, p.y);
l++;
}
for (int i = 0; i < 3; i++) {
// check if it is actually a greyscale image, take always the 1st band!
ImageFloat32 colorImageBand = null;
if (colorImage.getNumBands() == 1) {
colorImageBand = colorImage.getBand(0);
} else {
colorImageBand = colorImage.getBand(i);
}
// compute the integral image of the i-th band of the color 'image'
II integralband =
GeneralizedImageOps.createSingleBand(
integralType, colorImageBand.width, colorImageBand.height);
GIntegralImageOps.transform(colorImageBand, integralband);
// tell algorithms which image to process
// orientation.setImage(integralband);
descriptor.setImage(integralband);
int j = 0;
for (ScalePoint p : points) {
// estimate orientation
// orientation.setScale(p.scale);
// double angle = orientation.compute(p.x, p.y);
// extract the SURF description for this region
SurfFeature desc = descriptor.createDescription();
descriptor.describe(p.x, p.y, angles[j], p.scale, (TupleDesc_F64) desc);
double[] banddesc = desc.getValue();
if (perBandNormalization) {
banddesc = Normalization.normalizeL2(banddesc);
}
for (int k = 0; k < SURFLength; k++) {
descriptions[j][i * SURFLength + k] = banddesc[k];
}
j++;
}
}
return descriptions;
}