/** * Must call before any other functions. * @param numRegions Total number of regions. */ public void initializeMerge(int numRegions) { mergeList.resize(numRegions); for( int i = 0; i < numRegions; i++ ) mergeList.data[i] = i; }
@Override public void setTo( GrowQueue_I32 original ) { resize(original.size); System.arraycopy(original.data, 0, data, 0, size()); }
/** * Specify the data range * * @param minValue Minimum allowed value. (inclusive) * @param maxValue Maximum allowed value. (inclusive) */ public void setRange( int minValue , int maxValue ) { this.maxValue = maxValue; this.minValue = minValue; histogram.resize(maxValue-minValue+1); histIndexes.resize(maxValue-minValue+1); }
@Override public void process(List<FoundShape> input, int cloudSize) { goodShapes.clear(); cloudToShape.resize(cloudSize); for (int i = 0; i < cloudToShape.size; i++) { cloudToShape.data[i] = -1; } pruneFalseShapes(input, goodShapes); }
/** * Specify the data range * * @param minValue Minimum allowed value. (inclusive) * @param maxValue Maximum allowed value. (inclusive) */ public void setRange( int minValue , int maxValue ) { this.maxValue = maxValue; this.minValue = minValue; histogram.resize(maxValue-minValue+1); histIndexes.resize(maxValue-minValue+1); }
@Override public void setTo( GrowQueue_I32 original ) { resize(original.size); System.arraycopy(original.data, 0, data, 0, size()); }
@Override public void initialize(int imageWidth, int imageHeight, int sensorOrientation) { // predeclare some memory synchronized (contours) { contours.growArray(5000); edgeLengths.resize(1000); contours.size = 0; edgeLengths.size = 0; } }
@SuppressWarnings("unchecked") @Override public void setPoints(List<double[]> points, boolean trackIndicies) { // Make a copy because we mutate the lists this.items = points.toArray(new double[0][]); this.indexes = new GrowQueue_I32(); indexes.resize(points.size()); for (int i = 0; i < points.size(); i++) { indexes.data[i] = i; } this.root = buildFromPoints(0, items.length); }
@SuppressWarnings("unchecked") @Override public void setPoints(List<double[]> points, boolean trackIndicies) { // Make a copy because we mutate the lists this.items = points.toArray(new double[0][]); this.indexes = new GrowQueue_I32(); indexes.resize(points.size()); for (int i = 0; i < points.size(); i++) { indexes.data[i] = i; } this.root = buildFromPoints(0, items.length); }
/** * compute the probability that each region is the target conditional upon this image * the sumP and sumN are needed for image conditional probability * * NOTE: This is a big change from the original paper */ protected void selectBestRegionsFern(double totalP, double totalN) { for( int i = 0; i < fernInfo.size; i++ ) { TldRegionFernInfo info = fernInfo.get(i); double probP = info.sumP/totalP; double probN = info.sumN/totalN; // only consider regions with a higher P likelihood if( probP > probN ) { // reward regions with a large difference between the P and N values storageMetric.add(-(probP-probN)); storageRect.add( info.r ); } } // Select the N regions with the highest fern probability if( config.maximumCascadeConsider < storageMetric.size ) { int N = Math.min(config.maximumCascadeConsider, storageMetric.size); storageIndexes.resize(storageMetric.size); QuickSelect.selectIndex(storageMetric.data, N - 1, storageMetric.size, storageIndexes.data); for( int i = 0; i < N; i++ ) { fernRegions.add(storageRect.get(storageIndexes.get(i))); } } else { fernRegions.addAll(storageRect); } }
/** * Predeclares all memory required and sets data structures to their initial values */ protected void initialize(T input , GrayS32 output ) { this.graph = output; final int N = input.width*input.height; regionSize.resize(N); threshold.resize(N); for( int i = 0; i < N; i++ ) { regionSize.data[i] = 1; threshold.data[i] = K; graph.data[i] = i; // assign a unique label to each pixel since they are all their own region initially } edges.reset(); edgesNotMatched.reset(); }
public GrowQueue_I32 checkSource( FastQueue<AssociatedIndex> matches , int num ) { matched.resize(num); for( int i = 0; i < matched.size; i++ ) { matched.data[i] = 0; } for( int i = 0; i < matches.size; i++ ) { matched.data[matches.get(i).src] = 1; } unassociatedSrc.reset(); for( int i = 0; i < matched.size; i++ ) { if( matched.data[i] == 0 ) { unassociatedSrc.add(i); } } return unassociatedSrc; }
public GrowQueue_I32 checkDestination( FastQueue<AssociatedIndex> matches , int num ) { matched.resize(num); for( int i = 0; i < matched.size; i++ ) { matched.data[i] = 0; } for( int i = 0; i < matches.size; i++ ) { matched.data[matches.get(i).dst] = 1; } unassociatedDst.reset(); for( int i = 0; i < matched.size; i++ ) { if( matched.data[i] == 0 ) { unassociatedDst.add(i); } } return unassociatedDst; } }
@Override public void init(final int pointDimension, long randomSeed) { seedSelector.init(pointDimension,randomSeed); this.N = pointDimension; clusters = createQueue(pointDimension); workClusters = createQueue(pointDimension); bestClusters = createQueue(pointDimension); memberCount.resize(pointDimension); }
/** * Creates a new {@link KdTree} from the provided points. * * WARNING: Reference to each point is saved to reduce memory usage.. * * @param points Data points. * @return KdTre */ public KdTree construct(List<P> points , boolean trackIndexes ) { GrowQueue_I32 indexes = null; if( trackIndexes ) { indexes = new GrowQueue_I32(); indexes.resize(points.size()); for (int i = 0; i < indexes.size; i++) { indexes.data[i] = i; } } KdTree tree = memory.requestTree(splitter.getPointLength()); if( points.size() == 1 ) { tree.root = createLeaf(points,indexes); } else if( points.size() > 1 ) { tree.root = computeBranch(points, indexes ); } return tree; }
@Override public void init(final int pointDimension, long randomSeed) { seedSelector.init(pointDimension,randomSeed); this.N = pointDimension; clusters = createQueue(pointDimension); workClusters = createQueue(pointDimension); bestClusters = createQueue(pointDimension); memberCount.resize(pointDimension); }
private static List<double[]> findNeighbors( List<double[]> data , double[]target , double maxDistance , int maxN ) { List<double[]> ret = new ArrayList<double[]>(); List<double[]> found = new ArrayList<double[]>(); GrowQueue_F64 distances = new GrowQueue_F64(); GrowQueue_I32 indexes = new GrowQueue_I32(); for( int i = 0; i < data.size(); i++ ) { double[] d = data.get(i); double dx = d[0] - target[0]; double dy = d[1] - target[1]; double dist = dx*dx + dy*dy; if( dist <= maxDistance ) { distances.add(dist); found.add(d); } } indexes.resize(distances.size); maxN = Math.min(maxN,distances.size); QuickSelect.selectIndex(distances.data,maxN,distances.size,indexes.data); for( int i = 0; i < maxN; i++ ) { ret.add( found.get( indexes.data[i])); } return ret; }
private void performSegmentation() { long before = System.currentTimeMillis(); alg.segment(color, pixelToRegion); long after = System.currentTimeMillis(); System.out.println("Total time "+(after-before)); int numSegments = alg.getTotalSuperpixels(); // Computes the mean color inside each region ImageType<T> type = color.getImageType(); ComputeRegionMeanColor<T> colorize = FactorySegmentationAlg.regionMeanColor(type); FastQueue<float[]> segmentColor = new ColorQueue_F32(type.getNumBands()); segmentColor.resize(numSegments); GrowQueue_I32 regionMemberCount = new GrowQueue_I32(); regionMemberCount.resize(numSegments); ImageSegmentationOps.countRegionPixels(pixelToRegion, numSegments, regionMemberCount.data); colorize.process(color,pixelToRegion,regionMemberCount,segmentColor); VisualizeRegions.regionsColor(pixelToRegion,segmentColor,outColor); VisualizeRegions.regions(pixelToRegion,segmentColor.size(),outSegments); // Make edges appear black ConvertBufferedImage.convertTo(color,outBorder,true); VisualizeRegions.regionBorders(pixelToRegion,0x000000,outBorder); }
/** * Identifies which regions are to be pruned based on their member counts. Then sets up * data structures for graph and converting segment ID to prune ID. * * @return true If elements need to be pruned and false if not. */ protected boolean setupPruneList(GrowQueue_I32 regionMemberCount) { segmentPruneFlag.resize(regionMemberCount.size); pruneGraph.reset(); segmentToPruneID.resize(regionMemberCount.size); for( int i = 0; i < regionMemberCount.size; i++ ) { if( regionMemberCount.get(i) < minimumSize ) { segmentToPruneID.set(i, pruneGraph.size()); Node n = pruneGraph.grow(); n.init(i); segmentPruneFlag.set(i, true); } else { segmentPruneFlag.set(i, false); } } return pruneGraph.size() != 0; }
@Override public void segment(T input, GrayS32 output) { InputSanityCheck.checkSameShape(input,output); converted.reshape(input.width,input.height); GConvertImage.convert(input,converted); // segment the image alg.process(converted); alg.removeWatersheds(); numRegions = alg.getTotalRegions(); GrayS32 pixelToRegion = alg.getOutput(); // Merge small regions together if( pruneSmall != null ) { regionMemberCount.resize(numRegions); regionColor.resize(numRegions); ImageSegmentationOps.countRegionPixels(pixelToRegion,numRegions,regionMemberCount.data); pruneSmall.process(converted,pixelToRegion,regionMemberCount,regionColor); numRegions = regionMemberCount.size(); } output.setTo(pixelToRegion); }