/** See how well it processes an image which is not an GrayS32 */ @Test public void checkOtherType() { GrayS32 orig = new GrayS32(width, height); GImageMiscOps.fillUniform(orig, rand, 0, 20); GrayU8 orig8 = ConvertImage.convert(orig, (GrayU8) null); int N = 3; ImageDimension dimen = UtilWavelet.transformDimension(orig, N); GrayS32 found = new GrayS32(dimen.width, dimen.height); GrayS32 expected = new GrayS32(dimen.width, dimen.height); WaveletDescription<WlCoef_I32> desc = FactoryWaveletDaub.biorthogonal_I32(5, BorderType.REFLECT); GrayS32 storage = new GrayS32(dimen.width, dimen.height); WaveletTransformOps.transformN(desc, orig.clone(), expected, storage, N); WaveletTransformInt<GrayU8> alg = new WaveletTransformInt<>(desc, N, 0, 255, GrayU8.class); alg.transform(orig8, found); // see if the two techniques produced the same results BoofTesting.assertEquals(expected, found, 0); // see if it can convert it back GrayU8 reconstructed = new GrayU8(width, height); alg.invert(found, reconstructed); BoofTesting.assertEquals(orig8, reconstructed, 0); // make sure the input has not been modified BoofTesting.assertEquals(expected, found, 0); }
@Test public void compareToWaveletTransformOps() { GrayS32 orig = new GrayS32(width, height); GImageMiscOps.fillUniform(orig, rand, 0, 20); GrayS32 origCopy = orig.clone(); int N = 3; ImageDimension dimen = UtilWavelet.transformDimension(orig, N); GrayS32 found = new GrayS32(dimen.width, dimen.height); GrayS32 expected = new GrayS32(dimen.width, dimen.height); WaveletDescription<WlCoef_I32> desc = FactoryWaveletDaub.biorthogonal_I32(5, BorderType.REFLECT); GrayS32 storage = new GrayS32(dimen.width, dimen.height); WaveletTransformOps.transformN(desc, orig.clone(), expected, storage, N); WaveletTransformInt<GrayS32> alg = new WaveletTransformInt<>(desc, N, 0, 255, GrayS32.class); alg.transform(orig, found); // make sure the original input was not modified like it is in WaveletTransformOps BoofTesting.assertEquals(origCopy, orig, 0); // see if the two techniques produced the same results BoofTesting.assertEquals(expected, found, 0); // test inverse transform GrayS32 reconstructed = new GrayS32(width, height); alg.invert(found, reconstructed); BoofTesting.assertEquals(orig, reconstructed, 0); // make sure the input has not been modified BoofTesting.assertEquals(expected, found, 0); }
/** The XY and YX second derivatives should be indential */ private void testSecondDerivative(Method m1, Method m2) { Class params[] = m1.getParameterTypes(); ImageGray input = GeneralizedImageOps.createSingleBand(params[0], width, height); ImageGray derivX = GeneralizedImageOps.createSingleBand(params[1], width, height); ImageGray derivY = GeneralizedImageOps.createSingleBand(params[2], width, height); ImageGray derivXX = GeneralizedImageOps.createSingleBand(params[1], width, height); ImageGray derivYY = GeneralizedImageOps.createSingleBand(params[2], width, height); ImageGray derivXY = GeneralizedImageOps.createSingleBand(params[1], width, height); ImageGray derivYX = GeneralizedImageOps.createSingleBand(params[1], width, height); GImageMiscOps.fillUniform(input, rand, 0, 40); Object border; if (params[3] == ImageBorder_F32.class) { border = new ImageBorder1D_F32(BorderIndex1D_Wrap.class); } else { border = new ImageBorder1D_S32(BorderIndex1D_Wrap.class); } try { m1.invoke(null, input, derivX, derivY, border); m2.invoke(null, derivX, derivXX, derivXY, border); m2.invoke(null, derivY, derivYX, derivYY, border); } catch (IllegalAccessException | InvocationTargetException e) { throw new RuntimeException(e); } // BoofTesting.printDiff(derivXY,derivYX); BoofTesting.assertEquals(derivXY, derivYX, 1e-3f); }
public static void assertEquals(ImageBase imgA, ImageBase imgB, double tol) { // 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; if (Math.abs(difference) > 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++) { assertEquals(a.getBand(band), b.getBand(band), tol); } } else if (imgA instanceof ImageInterleaved) { ImageInterleaved a = (ImageInterleaved) imgA; ImageInterleaved b = (ImageInterleaved) imgB; if (a.getNumBands() != b.getNumBands()) throw new RuntimeException("Number of bands not equal"); int numBands = a.getNumBands(); for (int y = 0; y < imgA.height; y++) { for (int x = 0; x < imgA.width; x++) { for (int band = 0; band < numBands; band++) { double valA = GeneralizedImageOps.get(a, x, y, band); double valB = GeneralizedImageOps.get(b, x, y, band); double difference = valA - valB; if (Math.abs(difference) > tol) throw new RuntimeException( "Values not equal at (" + x + "," + y + ") " + valA + " " + valB); } } } } else { throw new RuntimeException("Unknown image type"); } }
// TODO make sure pixels outside are not modified of sub-matrix // todo have the submatrices be from different shaped inputs @SuppressWarnings({"unchecked"}) public static void checkSubImage( Object testClass, String function, boolean checkEquals, Object... inputParam) { try { ImageBase[] larger = new ImageBase[inputParam.length]; ImageBase[] subImg = new ImageBase[inputParam.length]; Class<?> paramDesc[] = new Class<?>[inputParam.length]; Object[] inputModified = new Object[inputParam.length]; for (int i = 0; i < inputParam.length; i++) { if (ImageBase.class.isAssignableFrom(inputParam[i].getClass())) { ImageBase<?> img = (ImageBase<?>) inputParam[i]; // copy the original image inside of a larger image larger[i] = img._createNew(img.getWidth() + 10, img.getHeight() + 12); // extract a sub-image and make it equivalent to the original image. subImg[i] = larger[i].subimage(5, 6, 5 + img.getWidth(), 6 + img.getHeight(), null); subImg[i].setTo(img); } // the first time it is called use the original inputs inputModified[i] = inputParam[i]; paramDesc[i] = inputParam[i].getClass(); } // first try it with the original image Method m = findMethod(testClass.getClass(), function, paramDesc); m.invoke(testClass, inputModified); // now try it with the sub-image for (int i = 0; i < inputModified.length; i++) { if (subImg[i] != null) inputModified[i] = subImg[i]; } m.invoke(testClass, inputModified); // the result should be the identical if (checkEquals) { for (int i = 0; i < inputParam.length; i++) { if (subImg[i] == null) continue; assertEquals((ImageBase) inputModified[i], subImg[i], 0); } } } catch (InvocationTargetException e) { throw new RuntimeException(e); } catch (IllegalAccessException e) { throw new RuntimeException(e); } }
private void compareToNaive( Image left, Image right, int minDisparity, int maxDisparity, int radiusX, int radiusY) { int w = left.width; int h = left.height; DisparityScoreSadRect<Image, Disparity> alg = createAlg(minDisparity, maxDisparity, radiusX, radiusY, compDisp); StereoDisparityWtoNaive<Image> naive = new StereoDisparityWtoNaive<Image>(minDisparity, maxDisparity, radiusX, radiusY); Disparity found = GeneralizedImageOps.createSingleBand(disparityType, w, h); ImageFloat32 expected = new ImageFloat32(w, h); alg.process(left, right, found); naive.process(left, right, expected); BoofTesting.assertEquals(found, expected, 1); }