code stringlengths 73 34.1k | label stringclasses 1
value |
|---|---|
boolean centerOnSquare(QrCode.Alignment pattern, float guessY, float guessX) {
float step = 1;
float bestMag = Float.MAX_VALUE;
float bestX = guessX;
float bestY = guessY;
for (int i = 0; i < 10; i++) {
for (int row = 0; row < 3; row++) {
float gridy = guessY - 1f + row;
for (int col = 0; col < 3;... | java |
boolean localize(QrCode.Alignment pattern, float guessY, float guessX)
{
// sample along the middle. Try to not sample the outside edges which could confuse it
for (int i = 0; i < arrayY.length; i++) {
float x = guessX - 1.5f + i*3f/12.0f;
float y = guessY - 1.5f + i*3f/12.0f;
arrayX[i] = reader.read(gue... | java |
public static void positive( TupleDesc_F64 input , TupleDesc_U8 output ) {
double max = 0;
for( int i = 0; i < input.size(); i++ ) {
double v = input.value[i];
if( v > max )
max = v;
}
if( max == 0 )
max = 1.0;
for( int i = 0; i < input.size(); i++ ) {
output.value[i] = (byte)(255.0*input.va... | java |
public static void real( TupleDesc_F64 input , TupleDesc_S8 output ) {
double max = 0;
for( int i = 0; i < input.size(); i++ ) {
double v = Math.abs(input.value[i]);
if( v > max )
max = v;
}
for( int i = 0; i < input.size(); i++ ) {
output.value[i] = (byte)(127.0*input.value[i]/max);
}
} | java |
public static void convertNcc( TupleDesc_F64 input , NccFeature output ) {
if( input.size() != output.size() )
throw new IllegalArgumentException("Feature lengths do not match.");
double mean = 0;
for (int i = 0; i < input.value.length; i++) {
mean += input.value[i];
}
mean /= input.value.length;
d... | java |
private static void convolve1D(GrayU8 gray) {
ImageBorder<GrayU8> border = FactoryImageBorder.wrap(BorderType.EXTENDED, gray);
Kernel1D_S32 kernel = new Kernel1D_S32(2);
kernel.offset = 1; // specify the kernel's origin
kernel.data[0] = 1;
kernel.data[1] = -1;
GrayS16 output = new GrayS16(gray.width,gray.h... | java |
private static void convolve2D(GrayU8 gray) {
// By default 2D kernels will be centered around width/2
Kernel2D_S32 kernel = new Kernel2D_S32(3);
kernel.set(1,0,2);
kernel.set(2,1,2);
kernel.set(0,1,-2);
kernel.set(1,2,-2);
// Output needs to handle the increased domain after convolution. Can't be 8bit
... | java |
private static void normalize2D(GrayU8 gray) {
// Create a Gaussian kernel with radius of 3
Kernel2D_S32 kernel = FactoryKernelGaussian.gaussian2D(GrayU8.class, -1, 3);
// Note that there is a more efficient way to compute this convolution since it is a separable kernel
// just use BlurImageOps instead.
// S... | java |
public void process( List<DMatrixRMaj> homographies ) {
if( assumeZeroSkew ) {
if( homographies.size() < 2 )
throw new IllegalArgumentException("At least two homographies are required. Found "+homographies.size());
} else if( homographies.size() < 3 ) {
throw new IllegalArgumentException("At least three h... | java |
private void computeV( DMatrixRMaj h1 ,DMatrixRMaj h2 , DMatrixRMaj v )
{
double h1x = h1.get(0,0);
double h1y = h1.get(1,0);
double h1z = h1.get(2,0);
double h2x = h2.get(0,0);
double h2y = h2.get(1,0);
double h2z = h2.get(2,0);
v.set(0,0,h1x*h2x);
v.set(0,1,h1x*h2y+h1y*h2x);
v.set(0,2,h1y*h2y);
... | java |
private void computeParam() {
// reduce overflow/underflow
CommonOps_DDRM.divide(b,CommonOps_DDRM.elementMaxAbs(b));
double B11 = b.get(0,0);
double B12 = b.get(1,0);
double B22 = b.get(2,0);
double B13 = b.get(3,0);
double B23 = b.get(4,0);
double B33 = b.get(5,0);
double temp0 = B12*B13 - B11*B23;... | java |
public static void hessianNaive(GrayF32 integral, int skip , int size ,
GrayF32 intensity)
{
final int w = intensity.width;
final int h = intensity.height;
// get convolution kernels for the second order derivatives
IntegralKernel kerXX = DerivativeIntegralImage.kernelDerivXX(size,null);
IntegralKe... | java |
@Override
public void openImageSet(String ...files ) {
synchronized (lockProcessing) {
if( processing ) {
JOptionPane.showMessageDialog(this, "Still processing");
return;
}
}
// disable the menu until it finish processing the images
setMenuBarEnabled(false);
super.openImageSet(files);
} | java |
private BufferedImage scaleBuffered( BufferedImage input ) {
int m = Math.max(input.getWidth(),input.getHeight());
if( m <= controls.maxImageSize )
return input;
else {
double scale = controls.maxImageSize/(double)m;
int w = (int)(scale*input.getWidth()+0.5);
int h = (int)(scale*input.getHeight()+0.5)... | java |
private int[] selectBestPair( SceneStructureMetric structure ) {
Se3_F64 w_to_0 = structure.views[0].worldToView;
Se3_F64 w_to_1 = structure.views[1].worldToView;
Se3_F64 w_to_2 = structure.views[2].worldToView;
Se3_F64 view0_to_1 = w_to_0.invert(null).concat(w_to_1,null);
Se3_F64 view0_to_2 = w_to_0.invert(... | java |
private double score( Se3_F64 se ) {
// Rodrigues_F64 rod = new Rodrigues_F64();
// ConvertRotation3D_F64.matrixToRodrigues(se.R,rod);
double x = Math.abs(se.T.x);
double y = Math.abs(se.T.y);
double z = Math.abs(se.T.z)+1e-8;
double r = Math.max(x/(y+z),y/(x+z));
// System.out.println(se.T+" angle="+rod... | java |
public void process(List<Point2D_I32> contour , GrowQueue_I32 vertexes , Polygon2D_F64 output ) {
int numDecreasing = 0;
for (int i = vertexes.size-1,j=0; j < vertexes.size; i=j,j++) {
if( vertexes.get(i) > vertexes.get(j ) )
numDecreasing++;
}
boolean decreasing = numDecreasing > 1;
output.vertexes... | java |
public boolean isDistorted() {
if( radial != null && radial.length > 0 ) {
for (int i = 0; i < radial.length; i++) {
if( radial[i] != 0 )
return true;
}
}
return t1 != 0 || t2 != 0;
} | java |
public void process( List<List<SquareNode>> clusters ) {
valid.reset();
for( int i = 0; i < clusters.size(); i++ ) {
List<SquareNode> graph = clusters.get(i);
if( graph.size() < minimumElements )
continue;
switch( checkNumberOfConnections(graph) ) {
case 1:orderIntoLine(graph); break;
case 2... | java |
int checkNumberOfConnections( List<SquareNode> graph ) {
int histogram[] = new int[5];
for (int i = 0; i < graph.size(); i++) {
histogram[ graph.get(i).getNumberOfConnections() ]++;
}
if( graph.size() == 1 ) {
if( histogram[0] != 1 )
return 0;
return 1;
} else if( histogram[1] == 2 ) {
// l... | java |
boolean addRowsToGrid(List<SquareNode> column, List<SquareNode> ordered) {
for (int i = 0; i < column.size(); i++) {
column.get(i).graph = 0;
}
// now add the rows by traversing down the column
int numFirsRow = 0;
for (int j = 0; j < column.size(); j++) {
SquareNode n = column.get(j);
n.graph = SEA... | java |
int addLineToGrid(SquareNode a, SquareNode b, List<SquareNode> list) {
int total = 2;
// double maxAngle = UtilAngle.radian(45);
while( true ) {
// double slopeX0 = b.center.x - a.center.x;
// double slopeY0 = b.center.y - a.center.y;
// double angleAB = Math.atan2(slopeY0,slopeX0);
// see which side ... | java |
static SquareNode pickNot( SquareNode target , SquareNode child ) {
for (int i = 0; i < 4; i++) {
SquareEdge e = target.edges[i];
if( e == null )
continue;
SquareNode c = e.destination(target);
if( c != child )
return c;
}
throw new RuntimeException("There was no odd one out some how");
} | java |
static SquareNode pickNot( SquareNode target , SquareNode child0 , SquareNode child1 ) {
for (int i = 0; i < 4; i++) {
SquareEdge e = target.edges[i];
if( e == null ) continue;
SquareNode c = e.destination(target);
if( c != child0 && c != child1 )
return c;
}
throw new RuntimeException("There was ... | java |
public static int countRegionPixels(GrayS32 labeled , int which ) {
int total = 0;
for( int y = 0; y < labeled.height; y++ ) {
int index = labeled.startIndex + y*labeled.stride;
for( int x = 0; x < labeled.width; x++ ) {
if( labeled.data[index++] == which ) {
total++;
}
}
}
return total;
... | java |
public static void countRegionPixels(GrayS32 labeled , int totalRegions , int counts[] ) {
Arrays.fill(counts,0,totalRegions,0);
for( int y = 0; y < labeled.height; y++ ) {
int index = labeled.startIndex + y*labeled.stride;
for( int x = 0; x < labeled.width; x++ ) {
counts[labeled.data[index++]]++;
}... | java |
public static void regionPixelId_to_Compact(GrayS32 graph, GrowQueue_I32 segmentId, GrayS32 output) {
InputSanityCheck.checkSameShape(graph,output);
// Change the label of root nodes to be the new compacted labels
for( int i = 0; i < segmentId.size; i++ ) {
graph.data[segmentId.data[i]] = i;
}
// In the... | java |
public static <II extends ImageGray<II>>
OrientationIntegral<II> image_ii( double objectRadiusToScale,
int sampleRadius , double samplePeriod , int sampleWidth,
double weightSigma , Class<II> integralImage)
{
return (OrientationIntegral<II>)
new ImplOrientationImageAverageIntegral(objectRad... | java |
public static <II extends ImageGray<II>>
OrientationIntegral<II> sliding_ii( ConfigSlidingIntegral config , Class<II> integralType)
{
if( config == null )
config = new ConfigSlidingIntegral();
config.checkValidity();
return (OrientationIntegral<II>)
new ImplOrientationSlidingWindowIntegral(config.object... | java |
public static <D extends ImageGray<D>>
OrientationHistogramSift<D> sift(ConfigSiftOrientation config , Class<D> derivType ) {
if( config == null )
config = new ConfigSiftOrientation();
config.checkValidity();
return new OrientationHistogramSift(config.histogramSize,config.sigmaEnlarge,derivType);
} | java |
public void setTemplate(T template, T mask , int maxMatches) {
this.template = template;
this.mask = mask;
this.maxMatches = maxMatches;
} | java |
public void setImage(T image ) {
match.setInputImage(image);
this.imageWidth = image.width;
this.imageHeight = image.height;
} | java |
public void process() {
// compute match intensities
if( mask == null )
match.process(template);
else
match.process(template,mask);
GrayF32 intensity = match.getIntensity();
int offsetX = 0;
int offsetY = 0;
// adjust intensity image size depending on if there is a border or not
if (!match.isBo... | java |
public void refreshAlgorithm() {
Object cookie = algCookies.get(algBox.getSelectedIndex());
String name = (String)algBox.getSelectedItem();
performSetAlgorithm(name, cookie);
} | java |
public boolean process(List<Point2D_I32> contour ) {
// Reset internal book keeping variables
reset();
if( loops ) {
// Reject pathological case
if (contour.size() < 3)
return false;
if (!findInitialTriangle(contour))
return false;
} else {
// Reject pathological case
if( contour.size()... | java |
boolean savePolyline() {
int N = loops ? 3 : 2;
// if a polyline of this size has already been saved then over write it
CandidatePolyline c;
if( list.size() <= polylines.size+N-1 ) {
c = polylines.get( list.size()-N );
// sanity check
if( c.splits.size != list.size() )
throw new RuntimeException("... | java |
static double computeScore( LinkedList<Corner> list , double cornerPenalty , boolean loops ) {
double sumSides = 0;
Element<Corner> e = list.getHead();
Element<Corner> end = loops ? null : list.getTail();
while( e != end ) {
sumSides += e.object.sideError;
e = e.next;
}
int numSides = loops ? list.si... | java |
boolean findInitialTriangle(List<Point2D_I32> contour) {
// find the first estimate for a corner
int cornerSeed = findCornerSeed(contour);
// see if it can reject the contour immediately
if( convex ) {
if( !isConvexUsingMaxDistantPoints(contour,0,cornerSeed))
return false;
}
// Select the second co... | java |
private boolean initializeScore(List<Point2D_I32> contour , boolean loops ) {
// Score each side
Element<Corner> e = list.getHead();
Element<Corner> end = loops ? null : list.getTail();
while( e != end ) {
if (convex && !isSideConvex(contour, e))
return false;
Element<Corner> n = e.next;
double e... | java |
void ensureTriangleOrder(List<Point2D_I32> contour ) {
Element<Corner> e = list.getHead();
Corner a = e.object;e=e.next;
Corner b = e.object;e=e.next;
Corner c = e.object;
int distB = CircularIndex.distanceP(a.index,b.index,contour.size());
int distC = CircularIndex.distanceP(a.index,c.index,contour.size()... | java |
boolean increaseNumberOfSidesByOne(List<Point2D_I32> contour, boolean loops ) {
// System.out.println("increase number of sides by one. list = "+list.size());
Element<Corner> selected = selectCornerToSplit(loops);
// No side can be split
if( selected == null )
return false;
// Update the corner who's side... | java |
boolean isSideConvex(List<Point2D_I32> contour, Element<Corner> e1) {
// a conservative estimate for concavity. Assumes a triangle and that the farthest
// point is equal to the distance between the two corners
Element<Corner> e2 = next(e1);
int length = CircularIndex.distanceP(e1.object.index,e2.object.index... | java |
Element<Corner> selectCornerToSplit( boolean loops ) {
Element<Corner> selected = null;
double bestChange = convex ? 0 : -Double.MAX_VALUE;
// Pick the side that if split would improve the overall score the most
Element<Corner> e=list.getHead();
Element<Corner> end = loops ? null : list.getTail();
while( ... | java |
Element<Corner> selectCornerToRemove(List<Point2D_I32> contour , ErrorValue sideError , boolean loops ) {
if( list.size() <= 3 )
return null;
// Pick the side that if split would improve the overall score the most
Element<Corner> target,end;
// if it loops any corner can be split. If it doesn't look the en... | java |
boolean removeCornerAndSavePolyline( Element<Corner> corner, double sideErrorAfterRemoved ) {
// System.out.println("removing a corner idx="+target.object.index);
// Note: the corner is "lost" until the next contour is fit. Not worth the effort to recycle
Element<Corner> p = previous(corner);
// go through t... | java |
static int findCornerSeed(List<Point2D_I32> contour ) {
Point2D_I32 a = contour.get(0);
int best = -1;
double bestDistance = -Double.MAX_VALUE;
for (int i = 1; i < contour.size(); i++) {
Point2D_I32 b = contour.get(i);
double d = distanceSq(a,b);
if( d > bestDistance ) {
bestDistance = d;
be... | java |
static int maximumDistance(List<Point2D_I32> contour , int indexA , int indexB ) {
Point2D_I32 a = contour.get(indexA);
Point2D_I32 b = contour.get(indexB);
int best = -1;
double bestDistance = -Double.MAX_VALUE;
for (int i = 0; i < contour.size(); i++) {
Point2D_I32 c = contour.get(i);
// can't sum s... | java |
double computeSideError(List<Point2D_I32> contour , int indexA , int indexB ) {
assignLine(contour, indexA, indexB, line);
// don't sample the end points because the error will be zero by definition
int numSamples;
double sumOfDistances = 0;
int length;
if( indexB >= indexA ) {
length = indexB-indexA-1;... | java |
void computePotentialSplitScore( List<Point2D_I32> contour , Element<Corner> e0 , boolean mustSplit )
{
Element<Corner> e1 = next(e0);
e0.object.splitable = canBeSplit(contour,e0,mustSplit);
if( e0.object.splitable ) {
setSplitVariables(contour, e0, e1);
}
} | java |
void setSplitVariables(List<Point2D_I32> contour, Element<Corner> e0, Element<Corner> e1) {
int distance0 = CircularIndex.distanceP(e0.object.index, e1.object.index, contour.size());
int index0 = CircularIndex.plusPOffset(e0.object.index,minimumSideLength,contour.size());
int index1 = CircularIndex.minusPOffset... | java |
boolean canBeSplit( List<Point2D_I32> contour, Element<Corner> e0 , boolean mustSplit ) {
Element<Corner> e1 = next(e0);
// NOTE: The contour is passed in but only the size of the contour matters. This was done to prevent
// changing the signature if the algorithm was changed later on.
int length = Circu... | java |
Element<Corner> next( Element<Corner> e ) {
if( e.next == null ) {
return list.getHead();
} else {
return e.next;
}
} | java |
Element<Corner> previous( Element<Corner> e ) {
if( e.previous == null ) {
return list.getTail();
} else {
return e.previous;
}
} | java |
static double distanceSq( Point2D_I32 a , Point2D_I32 b ) {
double dx = b.x-a.x;
double dy = b.y-a.y;
return dx*dx + dy*dy;
} | java |
public static void assignLine(List<Point2D_I32> contour, int indexA, int indexB, LineParametric2D_F64 line) {
Point2D_I32 endA = contour.get(indexA);
Point2D_I32 endB = contour.get(indexB);
line.p.x = endA.x;
line.p.y = endA.y;
line.slope.x = endB.x-endA.x;
line.slope.y = endB.y-endA.y;
} | java |
protected void splitPixels( int indexStart , int indexStop ) {
// too short to split
if( indexStart+1 >= indexStop )
return;
int indexSplit = selectSplitBetween(indexStart, indexStop);
if( indexSplit >= 0 ) {
splitPixels(indexStart, indexSplit);
splits.add(indexSplit);
splitPixels(indexSplit, inde... | java |
protected boolean splitSegments() {
boolean change = false;
work.reset();
for( int i = 0; i < splits.size-1; i++ ) {
int start = splits.data[i];
int end = splits.data[i+1];
int bestIndex = selectSplitBetween(start, end);
if( bestIndex >= 0 ) {
change |= true;
work.add(start);
work.add(be... | java |
protected boolean mergeSegments() {
// can't merge a single line
if( splits.size <= 2 )
return false;
boolean change = false;
work.reset();
// first point is always at the start
work.add(splits.data[0]);
for( int i = 0; i < splits.size-2; i++ ) {
if( selectSplitBetween(splits.data[i],splits.data[... | java |
public void initialize(PyramidDiscrete<I> image ) {
if( previousDerivX == null || previousDerivX.length != image.getNumLayers()
|| previousImage.getInputWidth() != image.getInputWidth() || previousImage.getInputHeight() != image.getInputHeight() ) {
declareDataStructures(image);
}
for( int i = 0; i < imag... | java |
protected void declareDataStructures(PyramidDiscrete<I> image) {
numPyramidLayers = image.getNumLayers();
previousDerivX = (D[])Array.newInstance(derivType,image.getNumLayers());
previousDerivY = (D[])Array.newInstance(derivType,image.getNumLayers());
currentDerivX = (D[])Array.newInstance(derivType,image.getN... | java |
public boolean process(ImagePyramid<I> image , Rectangle2D_F64 targetRectangle ) {
boolean success = true;
updateCurrent(image);
// create feature tracks
spawnGrid(targetRectangle);
// track features while computing forward/backward error and NCC error
if( !trackFeature() )
success = false;
// make... | java |
protected void updateCurrent(ImagePyramid<I> image) {
this.currentImage = image;
for( int i = 0; i < image.getNumLayers(); i++ ) {
gradient.process(image.getLayer(i), currentDerivX[i], currentDerivY[i]);
}
} | java |
protected void spawnGrid(Rectangle2D_F64 prevRect ) {
// Shrink the rectangle to ensure that all features are entirely contained inside
spawnRect.p0.x = prevRect.p0.x + featureRadius;
spawnRect.p0.y = prevRect.p0.y + featureRadius;
spawnRect.p1.x = prevRect.p1.x - featureRadius;
spawnRect.p1.y = prevRect.p1.y... | java |
public boolean process( T left , T right ) {
if( first ) {
associateL2R(left, right);
first = false;
} else {
// long time0 = System.currentTimeMillis();
associateL2R(left, right);
// long time1 = System.currentTimeMillis();
associateF2F();
// long time2 = System.currentTimeMillis();
cyclicCon... | java |
private void associateL2R( T left , T right ) {
// make the previous new observations into the new old ones
ImageInfo<TD> tmp = featsLeft1;
featsLeft1 = featsLeft0; featsLeft0 = tmp;
tmp = featsRight1;
featsRight1 = featsRight0; featsRight0 = tmp;
// detect and associate features in the two images
featsL... | java |
private void associateF2F()
{
quadViews.reset();
for( int i = 0; i < detector.getNumberOfSets(); i++ ) {
SetMatches matches = setMatches[i];
// old left to new left
assocSame.setSource(featsLeft0.location[i],featsLeft0.description[i]);
assocSame.setDestination(featsLeft1.location[i], featsLeft1.descr... | java |
private void cyclicConsistency() {
for( int i = 0; i < detector.getNumberOfSets(); i++ ) {
FastQueue<Point2D_F64> obs0 = featsLeft0.location[i];
FastQueue<Point2D_F64> obs1 = featsRight0.location[i];
FastQueue<Point2D_F64> obs2 = featsLeft1.location[i];
FastQueue<Point2D_F64> obs3 = featsRight1.location[i... | java |
private void describeImage(T left , ImageInfo<TD> info ) {
detector.process(left);
for( int i = 0; i < detector.getNumberOfSets(); i++ ) {
PointDescSet<TD> set = detector.getFeatureSet(i);
FastQueue<Point2D_F64> l = info.location[i];
FastQueue<TD> d = info.description[i];
for( int j = 0; j < set.getNum... | java |
private boolean estimateMotion() {
modelFitData.reset();
Point2D_F64 normLeft = new Point2D_F64();
Point2D_F64 normRight = new Point2D_F64();
// use 0 -> 1 stereo associations to estimate each feature's 3D position
for( int i = 0; i < quadViews.size; i++ ) {
QuadView obs = quadViews.get(i);
// conver... | java |
@Override
public void setEquirectangularShape( int width , int height ) {
super.setEquirectangularShape(width, height);
declareVectors(width, height);
// precompute vectors for each pixel
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
tools.equiToNormFV(x,y,vectors[y*width+x]);
... | java |
public static <T extends ImageBase<T>>
TrackerObjectQuad<T> meanShiftLikelihood(int maxIterations,
int numBins,
double maxPixelValue,
MeanShiftLikelihoodType modelType,
ImageType<T> imageType) {
PixelLikelihood<T> likelihood;
switch( modelType ) {
case HISTOGRAM:... | java |
public static <T extends ImageBase<T>>
TrackerObjectQuad<T> meanShiftComaniciu2003(ConfigComaniciu2003 config, ImageType<T> imageType ) {
TrackerMeanShiftComaniciu2003<T> alg = FactoryTrackerObjectAlgs.meanShiftComaniciu2003(config,imageType);
return new Comaniciu2003_to_TrackerObjectQuad<>(alg, imageType);
} | java |
public void updateBackground( T frame , GrayU8 segment ) {
updateBackground(frame);
segment(frame,segment);
} | java |
public void append( int bits , int numberOfBits , boolean swapOrder ) {
if( numberOfBits > 32 )
throw new IllegalArgumentException("Number of bits exceeds the size of bits");
int indexTail = size;
growArray(numberOfBits,true);
if( swapOrder ) {
for (int i = 0; i < numberOfBits; i++) {
set( indexTail ... | java |
public int read( int location , int length , boolean swapOrder ) {
if( length < 0 || length > 32 )
throw new IllegalArgumentException("Length can't exceed 32");
if( location + length > size )
throw new IllegalArgumentException("Attempting to read past the end");
// TODO speed up by reading in byte chunks
... | java |
public void growArray( int amountBits , boolean saveValue ) {
size = size+amountBits;
int N = size/8 + (size%8==0?0:1);
if( N > data.length ) {
// add in some buffer to avoid lots of calls to new
int extra = Math.min(1024,N+10);
byte[] tmp = new byte[N+extra];
if( saveValue )
System.arraycopy(dat... | java |
protected boolean computeH(DMatrixRMaj A, DMatrixRMaj H) {
if( !solverNullspace.process(A.copy(),1,H) )
return true;
H.numRows = 3;
H.numCols = 3;
return false;
} | java |
public static void undoNormalizationH(DMatrixRMaj M, NormalizationPoint2D N1, NormalizationPoint2D N2) {
SimpleMatrix a = SimpleMatrix.wrap(M);
SimpleMatrix b = SimpleMatrix.wrap(N1.matrix());
SimpleMatrix c_inv = SimpleMatrix.wrap(N2.matrixInv());
SimpleMatrix result = c_inv.mult(a).mult(b);
M.set(result.g... | java |
protected int addConicPairConstraints( AssociatedPairConic a , AssociatedPairConic b , DMatrixRMaj A , int rowA ) {
// s*C[i] = H^T*V[i]*H
// C[i] = a, C[j] = b
// Conic in view 1 is C and view 2 is V, e.g. x' = H*x. x' is in view 2 and x in view 1
UtilCurves_F64.convert(a.p1, C1);
UtilCurves_F64.convert(a.p... | java |
protected void initalize(T input) {
this.input = input;
pixels.resize(input.width * input.height);
initialSegments.reshape(input.width, input.height);
// number of usable pixels that cluster centers can be placed in
int numberOfUsable = (input.width-2*BORDER)*(input.height-2*BORDER);
gridInterval = (int)Ma... | java |
protected void initializeClusters() {
int offsetX = Math.max(BORDER,((input.width-1) % gridInterval)/2);
int offsetY = Math.max(BORDER,((input.height-1) % gridInterval)/2);
int clusterId = 0;
clusters.reset();
for( int y = offsetY; y < input.height-BORDER; y += gridInterval ) {
for( int x = offsetX; x < ... | java |
protected void perturbCenter( Cluster c , int x , int y ) {
float best = Float.MAX_VALUE;
int bestX=0,bestY=0;
for( int dy = -1; dy <= 1; dy++ ) {
for( int dx = -1; dx <= 1; dx++ ) {
float d = gradient(x + dx, y + dy);
if( d < best ) {
best = d;
bestX = dx;
bestY = dy;
}
}
}
... | java |
protected float gradient(int x, int y) {
float dx = getIntensity(x+1,y) - getIntensity(x-1,y);
float dy = getIntensity(x,y+1) - getIntensity(x,y-1);
return dx*dx + dy*dy;
} | java |
protected void computeClusterDistance() {
for( int i = 0; i < pixels.size; i++ ) {
pixels.data[i].reset();
}
for( int i = 0; i < clusters.size && !stopRequested; i++ ) {
Cluster c = clusters.data[i];
// compute search bounds
int centerX = (int)(c.x + 0.5f);
int centerY = (int)(c.y + 0.5f);
in... | java |
protected void updateClusters() {
for( int i = 0; i < clusters.size; i++ ) {
clusters.data[i].reset();
}
int indexPixel = 0;
for( int y = 0; y < input.height&& !stopRequested; y++ ) {
int indexInput = input.startIndex + y*input.stride;
for( int x =0; x < input.width; x++ , indexPixel++ , indexInput++)... | java |
public void assignLabelsToPixels( GrayS32 pixelToRegions ,
GrowQueue_I32 regionMemberCount ,
FastQueue<float[]> regionColor ) {
regionColor.reset();
for( int i = 0; i < clusters.size(); i++ ) {
float[] r = regionColor.grow();
float[] c = clusters.get(i).color;
for( int j = 0; j < num... | java |
public void process( DMatrixRMaj F , List<AssociatedPair> observations ,
int width , int height ) {
int centerX = width/2;
int centerY = height/2;
MultiViewOps.extractEpipoles(F, epipole1, epipole2);
checkEpipoleInside(width, height);
// compute the transform H which will send epipole2 to infinity
... | java |
private void checkEpipoleInside(int width, int height) {
double x1 = epipole1.x/epipole1.z;
double y1 = epipole1.y/epipole1.z;
double x2 = epipole2.x/epipole2.z;
double y2 = epipole2.y/epipole2.z;
if( x1 >= 0 && x1 < width && y1 >= 0 && y1 < height )
throw new IllegalArgumentException("First epipole is i... | java |
private SimpleMatrix translateToOrigin( int x0 , int y0 ) {
SimpleMatrix T = SimpleMatrix.identity(3);
T.set(0, 2, -x0);
T.set(1, 2, -y0);
return T;
} | java |
private SimpleMatrix computeAffineH( List<AssociatedPair> observations ,
DMatrixRMaj H , DMatrixRMaj Hzero ) {
SimpleMatrix A = new SimpleMatrix(observations.size(),3);
SimpleMatrix b = new SimpleMatrix(A.numRows(),1);
Point2D_F64 c = new Point2D_F64();
Point2D_F64 k = new Point2D_F64();
for( in... | java |
public static URL pathExampleURL( String path ) {
try {
File fpath = new File(path);
if (fpath.isAbsolute())
return fpath.toURI().toURL();
// Assume we are running inside of the project come
String pathToBase = getPathToBase();
if( pathToBase != null ) {
File pathExample = new File(pathToBase, ... | java |
public static URL ensureURL(String path ) {
path = systemToUnix(path);
URL url;
try {
url = new URL(path);
if( url.getProtocol().equals("jar")) {
return simplifyJarPath(url);
}
} catch (MalformedURLException e) {
// might just be a file reference.
try {
url = new File(path).toURI().toURL(... | java |
public static URL simplifyJarPath( URL url ) {
try {
String segments[] = url.toString().split(".jar!/");
String path = simplifyJarPath(segments[1]);
return new URL(segments[0]+".jar!/"+path);
} catch (IOException e) {
return url;
}
} | java |
public static String path( String path ) {
String pathToBase = getPathToBase();
if( pathToBase == null )
return path;
return new File(pathToBase,path).getAbsolutePath();
} | java |
public static String getPathToBase() {
String path = new File(".").getAbsoluteFile().getParent();
while( path != null ) {
File f = new File(path);
if( !f.exists() )
break;
String[] files = f.list();
if( files == null )
break;
boolean foundMain = false;
boolean foundExamples = false;
... | java |
public static String selectFile(boolean exitOnCancel) {
String fileName = null;
JFileChooser fc = new JFileChooser();
int returnVal = fc.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION) {
fileName = fc.getSelectedFile().getAbsolutePath();
} else if (exitOnCancel) {
System.exit(0);
... | java |
public static List<String> listByPrefix(String directory, String prefix, String suffix) {
List<String> ret = new ArrayList<>();
File d = new File(directory);
if( !d.isDirectory() ) {
try {
URL url = new URL(directory);
if( url.getProtocol().equals("file")) {
d = new File(url.getFile());
} el... | java |
public static List<String> listAllMime( String directory , String type ) {
List<String> ret = new ArrayList<>();
try {
// see if it's a URL or not
URL url = new URL(directory);
if( url.getProtocol().equals("file") ) {
directory = url.getFile();
} else if( url.getProtocol().equals("jar") ) {
ret... | java |
public boolean process(CameraPinholeBrown intrinsic , Se3_F64 planeToCamera )
{
proj.setPlaneToCamera(planeToCamera,true);
proj.setIntrinsic(intrinsic);
// find a bounding rectangle on the ground which is visible to the camera and at a high enough resolution
double x0 = Double.MAX_VALUE;
double y0 = Double.... | java |
public <T extends ImageBase<T>> OverheadView createOverhead( ImageType<T> imageType ) {
OverheadView ret = new OverheadView();
ret.image = imageType.createImage(overheadWidth,overheadHeight);
ret.cellSize = cellSize;
ret.centerX = centerX;
ret.centerY = centerY;
return ret;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.