/** * Selects pixels as corners which are above the threshold. */ public void process(GrayF32 intensity, QueueCorner corners ) { corners.reset(); float data[] = intensity.data; for( int y = 0; y < intensity.height; y++ ) { int startIndex = intensity.startIndex + y*intensity.stride; int endIndex = startIndex + intensity.width; for( int index = startIndex; index < endIndex; index++ ) { if( data[index] > thresh ) { int x = index-startIndex; corners.add(x,y); } } } }
/** * Computes the Hough transform using the image gradient and a binary image which flags pixels as being edges or not. * * @param derivX Image derivative along x-axis. * @param derivY Image derivative along y-axis. * @param binary Non-zero pixels are considered to be line pixels. */ public <D extends ImageGray> void transform(D derivX , D derivY , GrayU8 binary ) { InputSanityCheck.checkSameShape(derivX,derivY,binary); transform.reshape(derivX.width,derivY.height); ImageMiscOps.fill(transform,0); originX = derivX.width/2; originY = derivX.height/2; candidates.reset(); if( derivX instanceof GrayF32) _transform((GrayF32)derivX,(GrayF32)derivY,binary); else if( derivX instanceof GrayS16) _transform((GrayS16)derivX,(GrayS16)derivY,binary); else if( derivX instanceof GrayS32) _transform((GrayS32)derivX,(GrayS32)derivY,binary); else throw new IllegalArgumentException("Unsupported derivative image type: "+derivX.getClass().getSimpleName()); }
@Override public void processImage(int sourceID, long frameID, final BufferedImage buffered, ImageBase input) { if( detectorChanged ) { detectorChanged = false; // this can be done safely outside of the GUI thread controls.comboActions.get( controls.selectedAlgorithm ).run(); } final double seconds; long timeBefore = System.nanoTime(); detector.process((T)input); long timeAfter = System.nanoTime(); seconds = (timeAfter-timeBefore)*1e-9; synchronized (featureLock) { for (int i = 0; i < detector.totalSets(); i++) { QueueCorner src = detector.getPointSet(i); QueueCorner dst = sets.get(i); dst.reset(); dst.addAll(src); } } BoofSwingUtil.invokeNowOrLater(() -> { controls.setProcessingTime(seconds); imagePanel.setBufferedImage(buffered); imagePanel.repaint(); }); }
@Override public void process(GrayU8 gray) { detector.process(gray); synchronized (lockGui) { maximumsGUI.reset(); minimumsGUI.reset(); if( detector.totalSets() == 1 ) { maximumsGUI.addAll(detector.getPointSet(0)); } else { minimumsGUI.addAll(detector.getPointSet(0)); maximumsGUI.addAll(detector.getPointSet(1)); } } } }
excludeList.reset(); for (int i = 0; i < active.size(); i++) { PyramidKltFeature f = active.get(i);
excludeList.reset(); for (int i = 0; i < active.size(); i++) { PyramidKltFeature f = active.get(i);
private void selectBest(GrayF32 intensityImage, QueueCorner found , int numSelect, boolean positive) { if (numSelect > 0) { selectBest.setN(numSelect); selectBest.process(intensityImage, found,positive); QueueCorner best = selectBest.getBestCorners(); found.reset(); for( int i = 0; i < best.size; i++ ) { found.grow().set(best.get(i)); } } }
/** * Searches for local maximas and converts into lines. * * @return Found lines in the image. */ public FastQueue<LineParametric2D_F32> extractLines() { lines.reset(); foundLines.reset(); foundIntensity.reset(); extractor.process(transform,null, candidates,null, foundLines); for( int i = 0; i < foundLines.size(); i++ ) { Point2D_I16 p = foundLines.get(i); int x0 = p.x - originX; int y0 = p.y - originY; if( Math.abs(x0) >= minDistanceFromOrigin || Math.abs(y0) >= minDistanceFromOrigin ) { LineParametric2D_F32 l = lines.grow(); l.p.set(p.x,p.y); l.slope.set(-y0,x0); foundIntensity.push(transform.get(p.x,p.y)); } } return lines; }
/** * Extracts local max and/or min from the intensity image. If more than the maximum features are found then * only the most intense ones will be returned * @param intensity Feature image intensity */ public void process(GrayF32 intensity ) { originalMin.reset(); originalMax.reset(); nonmax.process(intensity,null,null,originalMin,originalMax); localExtreme.reset(); for (int i = 0; i < originalMin.size; i++) { Point2D_I16 p = originalMin.get(i); float val = intensity.unsafe_get(p.x,p.y); localExtreme.grow().set(-val,false,p); } for (int i = 0; i < originalMax.size; i++) { Point2D_I16 p = originalMax.get(i); float val = intensity.unsafe_get(p.x, p.y); localExtreme.grow().set(val,true,p); } if( localExtreme.size > maxTotalFeatures ) { QuickSelect.select(localExtreme.data, maxTotalFeatures, localExtreme.size); localExtreme.size = maxTotalFeatures; } }
@Override public void processImage(int sourceID, long frameID, BufferedImage buffered, ImageBase input) { original = ConvertBufferedImage.checkCopy(buffered, original); T gray = (T) input; deriv.setInput(gray); D derivX = deriv.getDerivative(true); D derivY = deriv.getDerivative(false); D derivXX = deriv.getDerivative(true, true); D derivYY = deriv.getDerivative(false, false); D derivXY = deriv.getDerivative(true, false); GrayF32 featureImg; synchronized (lockAlgorithm) { detector.process(gray, derivX, derivY, derivXX, derivYY, derivXY); featureImg = detector.getIntensity(); VisualizeImageData.colorizeSign(featureImg, visualized, ImageStatistics.maxAbs(featureImg)); synchronized (lockCorners) { minimums.reset(); minimums.addAll(detector.getMinimums()); maximums.reset(); maximums.addAll(detector.getMaximums()); } } SwingUtilities.invokeLater(() -> { changeViewImage(); imagePanel.repaint(); }); }
public void process(GrayF32 intensityImage, QueueCorner origCorners, boolean positive ) { bestCorners.reset();
public void process( T image , GrayF32 intensity ) { candidates.reset(); this.image = image; if( stride != image.stride ) { stride = image.stride; offsets = DiscretizedCircle.imageOffsets(radius, image.stride); } helper.setImage(image,offsets); for (int y = radius; y < image.height-radius; y++) { int indexIntensity = intensity.startIndex + y*intensity.stride + radius; int index = image.startIndex + y*image.stride + radius; for (int x = radius; x < image.width-radius; x++, index++,indexIntensity++) { helper.setThresholds(index); if( checkLower(index) ) { intensity.data[indexIntensity] = helper.scoreLower(index); candidates.add(x,y); } else if( checkUpper(index)) { intensity.data[indexIntensity] = helper.scoreUpper(index); candidates.add(x,y); } else { intensity.data[indexIntensity] = 0; } } } }
/** * Searches for local maximas and converts into lines. * * @return Found lines in the image. */ public FastQueue<LineParametric2D_F32> extractLines() { lines.reset(); foundLines.reset(); foundIntensity.reset(); extractor.process(transform, null,null,null, foundLines); int w2 = transform.width/2; for( int i = 0; i < foundLines.size(); i++ ) { Point2D_I16 p = foundLines.get(i); float r = (float)(r_max*(p.x-w2)/w2); float c = tableTrig.c[p.y]; float s = tableTrig.s[p.y]; float x0 = r*c+originX; float y0 = r*s+originY; foundIntensity.push( transform.get(p.x,p.y)); LineParametric2D_F32 l = lines.grow(); l.p.set(x0,y0); l.slope.set(-s,c); Point2D_F64 p2 = new Point2D_F64(); lineToCoordinate(l,p2); } return lines; }
candidates.reset(); extractor.process(intensity, null,null,null, candidates);
foundFeatures.reset(); extractor.setIgnoreBorder(size[level] / (2 * skip)); extractor.process(intensity[index1],null,null,null,foundFeatures);