idx int64 0 41.2k | question stringlengths 74 4.04k | target stringlengths 7 750 |
|---|---|---|
26,600 | 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 ; col ++ ) { float gridx = guessX - 1f + col ; samples [ row * 3 + col ] = reader . read ( gridy , gridx ) ; } } float dx = ( samples [ 2 ] + samples [ 5 ] + samples [ 8 ] ) - ( samples [ 0 ] + samples [ 3 ] + samples [ 6 ] ) ; float dy = ( samples [ 6 ] + samples [ 7 ] + samples [ 8 ] ) - ( samples [ 0 ] + samples [ 1 ] + samples [ 2 ] ) ; float r = ( float ) Math . sqrt ( dx * dx + dy * dy ) ; if ( bestMag > r ) { bestMag = r ; bestX = guessX ; bestY = guessY ; } else { step *= 0.75f ; } if ( r > 0 ) { guessX = bestX + step * dx / r ; guessY = bestY + step * dy / r ; } else { break ; } } pattern . moduleFound . x = bestX ; pattern . moduleFound . y = bestY ; reader . gridToImage ( ( float ) pattern . moduleFound . y , ( float ) pattern . moduleFound . x , pattern . pixel ) ; return true ; } | If the initial guess is within the inner white circle or black dot this will ensure that it is centered on the black dot |
26,601 | boolean localize ( QrCode . Alignment pattern , float guessY , float guessX ) { 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 ( guessY , x ) ; arrayY [ i ] = reader . read ( y , guessX ) ; } int downX = greatestDown ( arrayX ) ; if ( downX == - 1 ) return false ; int upX = greatestUp ( arrayX , downX ) ; if ( upX == - 1 ) return false ; int downY = greatestDown ( arrayY ) ; if ( downY == - 1 ) return false ; int upY = greatestUp ( arrayY , downY ) ; if ( upY == - 1 ) return false ; pattern . moduleFound . x = guessX - 1.5f + ( downX + upX ) * 3f / 24.0f ; pattern . moduleFound . y = guessY - 1.5f + ( downY + upY ) * 3f / 24.0f ; reader . gridToImage ( ( float ) pattern . moduleFound . y , ( float ) pattern . moduleFound . x , pattern . pixel ) ; return true ; } | Localizizes the alignment pattern crudely by searching for the black box in the center by looking for its edges in the gray scale image |
26,602 | 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 . value [ i ] / max ) ; } } | Converts a floating point description with all positive values into the 8 - bit integer descriptor by dividing each element in the input by the element maximum value and multiplying by 255 . |
26,603 | 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 ) ; } } | Converts a floating point description with real values into the 8 - bit integer descriptor by dividing each element in the input by the element maximum absolute value and multiplying by 127 . |
26,604 | 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 ; double variance = 0 ; for ( int i = 0 ; i < input . value . length ; i ++ ) { double d = output . value [ i ] = input . value [ i ] - mean ; variance += d * d ; } variance /= output . size ( ) ; output . mean = mean ; output . sigma = Math . sqrt ( variance ) ; } | Converts a regular feature description into a NCC feature description |
26,605 | private static void convolve1D ( GrayU8 gray ) { ImageBorder < GrayU8 > border = FactoryImageBorder . wrap ( BorderType . EXTENDED , gray ) ; Kernel1D_S32 kernel = new Kernel1D_S32 ( 2 ) ; kernel . offset = 1 ; kernel . data [ 0 ] = 1 ; kernel . data [ 1 ] = - 1 ; GrayS16 output = new GrayS16 ( gray . width , gray . height ) ; GConvolveImageOps . horizontal ( kernel , gray , output , border ) ; panel . addImage ( VisualizeImageData . standard ( output , null ) , "1D Horizontal" ) ; GConvolveImageOps . vertical ( kernel , gray , output , border ) ; panel . addImage ( VisualizeImageData . standard ( output , null ) , "1D Vertical" ) ; } | Convolves a 1D kernel horizontally and vertically |
26,606 | private static void convolve2D ( GrayU8 gray ) { 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 ) ; GrayS16 output = new GrayS16 ( gray . width , gray . height ) ; ImageBorder < GrayU8 > border = FactoryImageBorder . wrap ( BorderType . EXTENDED , gray ) ; GConvolveImageOps . convolve ( kernel , gray , output , border ) ; panel . addImage ( VisualizeImageData . standard ( output , null ) , "2D Kernel" ) ; } | Convolves a 2D kernel |
26,607 | private static void normalize2D ( GrayU8 gray ) { Kernel2D_S32 kernel = FactoryKernelGaussian . gaussian2D ( GrayU8 . class , - 1 , 3 ) ; GrayU8 output = new GrayU8 ( gray . width , gray . height ) ; GConvolveImageOps . convolveNormalized ( kernel , gray , output ) ; panel . addImage ( VisualizeImageData . standard ( output , null ) , "2D Normalized Kernel" ) ; } | Convolves a 2D normalized kernel . This kernel is divided by its sum after computation . |
26,608 | 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 homographies are required. Found " + homographies . size ( ) ) ; } if ( assumeZeroSkew ) { setupA_NoSkew ( homographies ) ; if ( ! solverNull . process ( A , 1 , b ) ) throw new RuntimeException ( "SVD failed" ) ; computeParam_ZeroSkew ( ) ; } else { setupA ( homographies ) ; if ( ! solverNull . process ( A , 1 , b ) ) throw new RuntimeException ( "SVD failed" ) ; computeParam ( ) ; } if ( MatrixFeatures_DDRM . hasUncountable ( K ) ) { throw new RuntimeException ( "Failed!" ) ; } } | Given a set of homographies computed from a sequence of images that observe the same plane it estimates the camera s calibration . |
26,609 | 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 ) ; v . set ( 0 , 3 , h1z * h2x + h1x * h2z ) ; v . set ( 0 , 4 , h1z * h2y + h1y * h2z ) ; v . set ( 0 , 5 , h1z * h2z ) ; } | This computes the v_ij vector found in the paper . |
26,610 | private void computeParam ( ) { 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 ; double temp1 = B11 * B22 - B12 * B12 ; double v0 = temp0 / temp1 ; double lambda = B33 - ( B13 * B13 + v0 * temp0 ) / B11 ; double a = Math . sqrt ( Math . abs ( lambda / B11 ) ) ; double b = Math . sqrt ( Math . abs ( lambda * B11 / temp1 ) ) ; double c = - B12 * b / B11 ; double u0 = c * v0 / a - B13 / B11 ; K . set ( 0 , 0 , a ) ; K . set ( 0 , 1 , c ) ; K . set ( 0 , 2 , u0 ) ; K . set ( 1 , 1 , b ) ; K . set ( 1 , 2 , v0 ) ; K . set ( 2 , 2 , 1 ) ; } | Compute the calibration parameters from the b matrix . |
26,611 | public static void hessianNaive ( GrayF32 integral , int skip , int size , GrayF32 intensity ) { final int w = intensity . width ; final int h = intensity . height ; IntegralKernel kerXX = DerivativeIntegralImage . kernelDerivXX ( size , null ) ; IntegralKernel kerYY = DerivativeIntegralImage . kernelDerivYY ( size , null ) ; IntegralKernel kerXY = DerivativeIntegralImage . kernelDerivXY ( size , null ) ; float norm = 1.0f / ( size * size ) ; for ( int y = 0 ; y < h ; y ++ ) { for ( int x = 0 ; x < w ; x ++ ) { int xx = x * skip ; int yy = y * skip ; computeHessian ( integral , intensity , kerXX , kerYY , kerXY , norm , y , yy , x , xx ) ; } } } | Brute force approach which is easy to validate through visual inspection . |
26,612 | public void openImageSet ( String ... files ) { synchronized ( lockProcessing ) { if ( processing ) { JOptionPane . showMessageDialog ( this , "Still processing" ) ; return ; } } setMenuBarEnabled ( false ) ; super . openImageSet ( files ) ; } | Prevent the user from tring to process more than one image at once |
26,613 | 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 ) ; BufferedImage output = new BufferedImage ( w , h , input . getType ( ) ) ; Planar < GrayU8 > a = new Planar < > ( GrayU8 . class , input . getWidth ( ) , input . getHeight ( ) , 3 ) ; Planar < GrayU8 > b = new Planar < > ( GrayU8 . class , w , h , 3 ) ; ConvertBufferedImage . convertFrom ( input , a , true ) ; AverageDownSampleOps . down ( a , b ) ; ConvertBufferedImage . convertTo ( b , output , true ) ; return output ; } } | Scale buffered image so that it meets the image size restrictions |
26,614 | 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 ( null ) . concat ( w_to_2 , null ) ; Se3_F64 view1_to_2 = w_to_1 . invert ( null ) . concat ( w_to_2 , null ) ; Se3_F64 candidates [ ] = new Se3_F64 [ ] { view0_to_1 , view0_to_2 , view1_to_2 } ; int best = - 1 ; double bestScore = Double . MAX_VALUE ; for ( int i = 0 ; i < candidates . length ; i ++ ) { double s = score ( candidates [ i ] ) ; System . out . println ( "stereo score[" + i + "] = " + s ) ; if ( s < bestScore ) { bestScore = s ; best = i ; } } switch ( best ) { case 0 : return new int [ ] { 0 , 1 } ; case 1 : return new int [ ] { 0 , 2 } ; case 2 : return new int [ ] { 1 , 2 } ; } throw new RuntimeException ( "BUG!" ) ; } | Select two views which are the closest to an idea stereo pair . Little rotation and little translation along z - axis |
26,615 | private double score ( Se3_F64 se ) { 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 ) ) ; return 1.0 / r ; } | Give lower scores to transforms with no rotation and translations along x or y axis . |
26,616 | 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 . resize ( vertexes . size ) ; lines . resize ( vertexes . size ) ; for ( int i = vertexes . size - 1 , j = 0 ; j < vertexes . size ; i = j , j ++ ) { int idx0 = vertexes . get ( i ) ; int idx1 = vertexes . get ( j ) ; if ( decreasing ) { int tmp = idx0 ; idx0 = idx1 ; idx1 = tmp ; } if ( idx0 > idx1 ) { work . clear ( ) ; for ( int k = idx0 ; k < contour . size ( ) ; k ++ ) { work . add ( contour . get ( k ) ) ; } for ( int k = 0 ; k < idx1 ; k ++ ) { work . add ( contour . get ( k ) ) ; } FitLine_I32 . polar ( work , 0 , work . size ( ) , polar ) ; } else { FitLine_I32 . polar ( contour , idx0 , idx1 - idx0 , polar ) ; } UtilLine2D_F64 . convert ( polar , lines . get ( i ) ) ; } for ( int i = vertexes . size - 1 , j = 0 ; j < vertexes . size ; i = j , j ++ ) { LineGeneral2D_F64 lineA = lines . get ( i ) ; LineGeneral2D_F64 lineB = lines . get ( j ) ; Intersection2D_F64 . intersection ( lineA , lineB , output . get ( j ) ) ; } } | Refines the estimate using all the points in the contour |
26,617 | 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 ; } | If true then distortion parameters are specified . |
26,618 | 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 : orderIntoGrid ( graph ) ; break ; } } } | Converts the set of provided clusters into ordered grids . |
26,619 | 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 ) { if ( histogram [ 0 ] != 0 ) return 0 ; if ( histogram [ 2 ] != graph . size ( ) - 2 ) return 0 ; if ( histogram [ 3 ] != 0 ) return 0 ; if ( histogram [ 4 ] != 0 ) return 0 ; return 1 ; } else { if ( histogram [ 0 ] != 0 ) return 0 ; if ( histogram [ 1 ] != 0 ) return 0 ; if ( histogram [ 2 ] != 4 ) return 0 ; return 2 ; } } | Does a weak check on the number of edges in the graph . Since the structure isn t known it can t make harder checks |
26,620 | boolean addRowsToGrid ( List < SquareNode > column , List < SquareNode > ordered ) { for ( int i = 0 ; i < column . size ( ) ; i ++ ) { column . get ( i ) . graph = 0 ; } int numFirsRow = 0 ; for ( int j = 0 ; j < column . size ( ) ; j ++ ) { SquareNode n = column . get ( j ) ; n . graph = SEARCHED ; ordered . add ( n ) ; SquareNode nextRow ; if ( j == 0 ) { if ( n . getNumberOfConnections ( ) != 2 ) { if ( verbose ) System . err . println ( "Unexpected number of connections. want 2 found " + n . getNumberOfConnections ( ) ) ; return true ; } nextRow = pickNot ( n , column . get ( j + 1 ) ) ; } else if ( j == column . size ( ) - 1 ) { if ( n . getNumberOfConnections ( ) != 2 ) { if ( verbose ) System . err . println ( "Unexpected number of connections. want 2 found " + n . getNumberOfConnections ( ) ) ; return true ; } nextRow = pickNot ( n , column . get ( j - 1 ) ) ; } else { if ( n . getNumberOfConnections ( ) != 3 ) { if ( verbose ) System . err . println ( "Unexpected number of connections. want 2 found " + n . getNumberOfConnections ( ) ) ; return true ; } nextRow = pickNot ( n , column . get ( j - 1 ) , column . get ( j + 1 ) ) ; } nextRow . graph = SEARCHED ; ordered . add ( nextRow ) ; int numberLine = addLineToGrid ( n , nextRow , ordered ) ; if ( j == 0 ) { numFirsRow = numberLine ; } else if ( numberLine != numFirsRow ) { if ( verbose ) System . err . println ( "Number of elements in rows do not match." ) ; return true ; } } return false ; } | Competes the graph by traversing down the first column and adding the rows one at a time |
26,621 | int addLineToGrid ( SquareNode a , SquareNode b , List < SquareNode > list ) { int total = 2 ; while ( true ) { boolean matched = false ; int side ; for ( side = 0 ; side < 4 ; side ++ ) { if ( b . edges [ side ] != null && b . edges [ side ] . destination ( b ) == a ) { matched = true ; break ; } } if ( ! matched ) { throw new RuntimeException ( "BUG!" ) ; } side = ( side + 2 ) % 4 ; if ( b . edges [ side ] == null ) break ; SquareNode c = b . edges [ side ] . destination ( b ) ; if ( c . graph == SEARCHED ) break ; total ++ ; c . graph = SEARCHED ; list . add ( c ) ; a = b ; b = c ; } return total ; } | Add all the nodes into the list which lie along the line defined by a and b . a is assumed to be an end point . Care is taken to not cycle . |
26,622 | 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" ) ; } | There are only two edges on target . Pick the edge which does not go to the provided child |
26,623 | 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 no odd one out some how" ) ; } | There are only three edges on target and two of them are known . Pick the one which isn t an inptu child |
26,624 | 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 ; } | Counts the number of instances of which inside the labeled image . |
26,625 | 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 ++ ] ] ++ ; } } } | Counts the number of pixels in all regions . Regions must be have labels from 0 to totalRegions - 1 . |
26,626 | public static void regionPixelId_to_Compact ( GrayS32 graph , GrowQueue_I32 segmentId , GrayS32 output ) { InputSanityCheck . checkSameShape ( graph , output ) ; for ( int i = 0 ; i < segmentId . size ; i ++ ) { graph . data [ segmentId . data [ i ] ] = i ; } for ( int y = 0 ; y < output . height ; y ++ ) { int indexGraph = graph . startIndex + y * graph . stride ; int indexOut = output . startIndex + y * output . stride ; for ( int x = 0 ; x < output . width ; x ++ , indexGraph ++ , indexOut ++ ) { output . data [ indexOut ] = graph . data [ graph . data [ indexGraph ] ] ; } } for ( int i = 0 ; i < segmentId . size ; i ++ ) { int indexGraph = segmentId . data [ i ] - graph . startIndex ; int x = indexGraph % graph . stride ; int y = indexGraph / graph . stride ; output . data [ output . startIndex + y * output . stride + x ] = i ; } } | Compacts the region labels such that they are consecutive numbers starting from 0 . The ID of a root node must the index of a pixel in the graph image taking in account the change in coordinates for sub - images . |
26,627 | 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 ( objectRadiusToScale , sampleRadius , samplePeriod , sampleWidth , weightSigma , integralImage ) ; } | Estimates the orientation without calculating the image derivative . |
26,628 | 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 . objectRadiusToScale , config . samplePeriod , config . windowSize , config . radius , config . weightSigma , config . sampleWidth , integralType ) ; } | Estimates the orientation of a region by using a sliding window across the different potential angles . |
26,629 | 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 ) ; } | Estimates multiple orientations as specified in SIFT paper . |
26,630 | public void setTemplate ( T template , T mask , int maxMatches ) { this . template = template ; this . mask = mask ; this . maxMatches = maxMatches ; } | Specifies the template to search for and the maximum number of matches to return . |
26,631 | public void setImage ( T image ) { match . setInputImage ( image ) ; this . imageWidth = image . width ; this . imageHeight = image . height ; } | Specifies the input image which the template is to be found inside . |
26,632 | public void process ( ) { if ( mask == null ) match . process ( template ) ; else match . process ( template , mask ) ; GrayF32 intensity = match . getIntensity ( ) ; int offsetX = 0 ; int offsetY = 0 ; if ( ! match . isBorderProcessed ( ) ) { int x0 = match . getBorderX0 ( ) ; int x1 = imageWidth - ( template . width - x0 ) ; int y0 = match . getBorderY0 ( ) ; int y1 = imageHeight - ( template . height - y0 ) ; intensity = intensity . subimage ( x0 , y0 , x1 , y1 , null ) ; } else { offsetX = match . getBorderX0 ( ) ; offsetY = match . getBorderY0 ( ) ; } candidates . reset ( ) ; extractor . process ( intensity , null , null , null , candidates ) ; if ( scores . length < candidates . size ) { scores = new float [ candidates . size ] ; indexes = new int [ candidates . size ] ; } for ( int i = 0 ; i < candidates . size ; i ++ ) { Point2D_I16 p = candidates . get ( i ) ; scores [ i ] = - intensity . get ( p . x , p . y ) ; } int N = Math . min ( maxMatches , candidates . size ) ; QuickSelect . selectIndex ( scores , N , candidates . size , indexes ) ; results . reset ( ) ; for ( int i = 0 ; i < N ; i ++ ) { Point2D_I16 p = candidates . get ( indexes [ i ] ) ; Match m = results . grow ( ) ; m . score = - scores [ indexes [ i ] ] ; m . set ( p . x - offsetX , p . y - offsetY ) ; } } | Performs template matching . |
26,633 | public void refreshAlgorithm ( ) { Object cookie = algCookies . get ( algBox . getSelectedIndex ( ) ) ; String name = ( String ) algBox . getSelectedItem ( ) ; performSetAlgorithm ( name , cookie ) ; } | Tells it to switch again to the current algorithm . Useful if the input has changed and information needs to be rendered again . |
26,634 | public boolean process ( List < Point2D_I32 > contour ) { reset ( ) ; if ( loops ) { if ( contour . size ( ) < 3 ) return false ; if ( ! findInitialTriangle ( contour ) ) return false ; } else { if ( contour . size ( ) < 2 ) return false ; addCorner ( 0 ) ; addCorner ( contour . size ( ) - 1 ) ; initializeScore ( contour , false ) ; } savePolyline ( ) ; sequentialSideFit ( contour , loops ) ; if ( fatalError ) return false ; int MIN_SIZE = loops ? 3 : 2 ; double bestScore = Double . MAX_VALUE ; int bestSize = - 1 ; for ( int i = 0 ; i < Math . min ( maxSides - ( MIN_SIZE - 1 ) , polylines . size ) ; i ++ ) { if ( polylines . get ( i ) . score < bestScore ) { bestPolyline = polylines . get ( i ) ; bestScore = bestPolyline . score ; bestSize = i + MIN_SIZE ; } } if ( bestSize < minSides ) { return false ; } for ( int i = 0 , j = bestSize - 1 ; i < bestSize ; j = i , i ++ ) { Point2D_I32 a = contour . get ( bestPolyline . splits . get ( i ) ) ; Point2D_I32 b = contour . get ( bestPolyline . splits . get ( j ) ) ; double length = a . distance ( b ) ; double thresholdSideError = this . maxSideError . compute ( length ) ; if ( bestPolyline . sideErrors . get ( i ) >= thresholdSideError * thresholdSideError ) { bestPolyline = null ; return false ; } } return true ; } | Process the contour and returns true if a polyline could be found . |
26,635 | boolean savePolyline ( ) { int N = loops ? 3 : 2 ; CandidatePolyline c ; if ( list . size ( ) <= polylines . size + N - 1 ) { c = polylines . get ( list . size ( ) - N ) ; if ( c . splits . size != list . size ( ) ) throw new RuntimeException ( "Egads saved polylines aren't in the expected order" ) ; } else { c = polylines . grow ( ) ; c . reset ( ) ; c . score = Double . MAX_VALUE ; } double foundScore = computeScore ( list , cornerScorePenalty , loops ) ; if ( c . score > foundScore ) { c . score = foundScore ; c . splits . reset ( ) ; c . sideErrors . reset ( ) ; Element < Corner > e = list . getHead ( ) ; double maxSideError = 0 ; while ( e != null ) { maxSideError = Math . max ( maxSideError , e . object . sideError ) ; c . splits . add ( e . object . index ) ; c . sideErrors . add ( e . object . sideError ) ; e = e . next ; } c . maxSideError = maxSideError ; return true ; } else { return false ; } } | Saves the current polyline |
26,636 | 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 . size ( ) : list . size ( ) - 1 ; return sumSides / numSides + cornerPenalty * numSides ; } | Computes the score for a list |
26,637 | boolean findInitialTriangle ( List < Point2D_I32 > contour ) { int cornerSeed = findCornerSeed ( contour ) ; if ( convex ) { if ( ! isConvexUsingMaxDistantPoints ( contour , 0 , cornerSeed ) ) return false ; } splitter . selectSplitPoint ( contour , 0 , cornerSeed , resultsA ) ; splitter . selectSplitPoint ( contour , cornerSeed , 0 , resultsB ) ; if ( splitter . compareScore ( resultsA . score , resultsB . score ) >= 0 ) { addCorner ( resultsA . index ) ; addCorner ( cornerSeed ) ; } else { addCorner ( cornerSeed ) ; addCorner ( resultsB . index ) ; } int index0 = list . getHead ( ) . object . index ; int index1 = list . getHead ( ) . next . object . index ; int index2 = maximumDistance ( contour , index0 , index1 ) ; addCorner ( index2 ) ; ensureTriangleOrder ( contour ) ; return initializeScore ( contour , true ) ; } | Select an initial triangle . A good initial triangle is needed . By good it should minimize the error of the contour from each side |
26,638 | private boolean initializeScore ( List < Point2D_I32 > contour , boolean loops ) { 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 error ; if ( n == null ) { error = computeSideError ( contour , e . object . index , list . getHead ( ) . object . index ) ; } else { error = computeSideError ( contour , e . object . index , n . object . index ) ; } e . object . sideError = error ; e = n ; } e = list . getHead ( ) ; while ( e != end ) { computePotentialSplitScore ( contour , e , list . size ( ) < minSides ) ; e = e . next ; } return true ; } | Computes the score and potential split for each side |
26,639 | 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 ( ) ) ; if ( distB > distC ) { list . reset ( ) ; list . pushTail ( a ) ; list . pushTail ( c ) ; list . pushTail ( b ) ; } } | Make sure the next corner after the head is the closest one to the head |
26,640 | boolean increaseNumberOfSidesByOne ( List < Point2D_I32 > contour , boolean loops ) { Element < Corner > selected = selectCornerToSplit ( loops ) ; if ( selected == null ) return false ; selected . object . sideError = selected . object . splitError0 ; Corner c = corners . grow ( ) ; c . reset ( ) ; c . index = selected . object . splitLocation ; c . sideError = selected . object . splitError1 ; Element < Corner > cornerE = list . insertAfter ( selected , c ) ; if ( convex && ! isSideConvex ( contour , selected ) ) return false ; else { computePotentialSplitScore ( contour , cornerE , list . size ( ) < minSides ) ; computePotentialSplitScore ( contour , selected , list . size ( ) < minSides ) ; savePolyline ( ) ; return true ; } } | Increase the number of sides in the polyline . This is done greedily selecting the side which would improve the score by the most of it was split . |
26,641 | boolean isSideConvex ( List < Point2D_I32 > contour , Element < Corner > e1 ) { Element < Corner > e2 = next ( e1 ) ; int length = CircularIndex . distanceP ( e1 . object . index , e2 . object . index , contour . size ( ) ) ; Point2D_I32 p0 = contour . get ( e1 . object . index ) ; Point2D_I32 p1 = contour . get ( e2 . object . index ) ; double d = p0 . distance ( p1 ) ; if ( length >= d * convexTest ) { return false ; } return true ; } | Checks to see if the side could belong to a convex shape |
26,642 | Element < Corner > selectCornerToSplit ( boolean loops ) { Element < Corner > selected = null ; double bestChange = convex ? 0 : - Double . MAX_VALUE ; Element < Corner > e = list . getHead ( ) ; Element < Corner > end = loops ? null : list . getTail ( ) ; while ( e != end ) { Corner c = e . object ; if ( ! c . splitable ) { e = e . next ; continue ; } double change = c . sideError * 2 - c . splitError0 - c . splitError1 ; if ( change < 0 ) { change = - change ; } if ( change > bestChange ) { bestChange = change ; selected = e ; } e = e . next ; } return selected ; } | Selects the best side to split the polyline at . |
26,643 | Element < Corner > selectCornerToRemove ( List < Point2D_I32 > contour , ErrorValue sideError , boolean loops ) { if ( list . size ( ) <= 3 ) return null ; Element < Corner > target , end ; if ( loops ) { target = list . getHead ( ) ; end = null ; } else { target = list . getHead ( ) . next ; end = list . getTail ( ) ; } Element < Corner > best = null ; double bestScore = - Double . MAX_VALUE ; while ( target != end ) { Element < Corner > p = previous ( target ) ; Element < Corner > n = next ( target ) ; double before = ( p . object . sideError + target . object . sideError ) / 2.0 + cornerScorePenalty ; double after = computeSideError ( contour , p . object . index , n . object . index ) ; if ( before - after > bestScore ) { bestScore = before - after ; best = target ; sideError . value = after ; } target = target . next ; } return best ; } | Selects the best corner to remove . If no corner was found that can be removed then null is returned |
26,644 | boolean removeCornerAndSavePolyline ( Element < Corner > corner , double sideErrorAfterRemoved ) { Element < Corner > p = previous ( corner ) ; p . object . sideError = sideErrorAfterRemoved ; list . remove ( corner ) ; return savePolyline ( ) ; } | Remove the corner from the current polyline . If the new polyline has a better score than the currently saved one with the same number of corners save it |
26,645 | 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 ; best = i ; } } return best ; } | The seed corner is the point farther away from the first point . In a perfect polygon with no noise this should be a corner . |
26,646 | 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 ) ; double d = distanceAbs ( a , c ) + distanceAbs ( b , c ) ; if ( d > bestDistance ) { bestDistance = d ; best = i ; } } return best ; } | Finds the point in the contour which maximizes the distance between points A and B . |
26,647 | double computeSideError ( List < Point2D_I32 > contour , int indexA , int indexB ) { assignLine ( contour , indexA , indexB , line ) ; int numSamples ; double sumOfDistances = 0 ; int length ; if ( indexB >= indexA ) { length = indexB - indexA - 1 ; numSamples = Math . min ( length , maxNumberOfSideSamples ) ; for ( int i = 0 ; i < numSamples ; i ++ ) { int index = indexA + 1 + length * i / numSamples ; Point2D_I32 p = contour . get ( index ) ; sumOfDistances += Distance2D_F64 . distanceSq ( line , p . x , p . y ) ; } sumOfDistances /= numSamples ; } else { length = contour . size ( ) - indexA - 1 + indexB ; numSamples = Math . min ( length , maxNumberOfSideSamples ) ; for ( int i = 0 ; i < numSamples ; i ++ ) { int where = length * i / numSamples ; int index = ( indexA + 1 + where ) % contour . size ( ) ; Point2D_I32 p = contour . get ( index ) ; sumOfDistances += Distance2D_F64 . distanceSq ( line , p . x , p . y ) ; } sumOfDistances /= numSamples ; } if ( numSamples > 0 ) return sumOfDistances ; else return 0 ; } | Scores a side based on the sum of Euclidean distance squared of each point along the line . Euclidean squared is used because its fast to compute |
26,648 | 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 ) ; } } | Computes the split location and the score of the two new sides if it s split there |
26,649 | 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 ( e1 . object . index , minimumSideLength , contour . size ( ) ) ; splitter . selectSplitPoint ( contour , index0 , index1 , resultsA ) ; if ( convex ) { Point2D_I32 a = contour . get ( e0 . object . index ) ; Point2D_I32 b = contour . get ( resultsA . index ) ; Point2D_I32 c = contour . get ( next ( e0 ) . object . index ) ; if ( UtilPolygons2D_I32 . isPositiveZ ( a , b , c ) ) { e0 . object . splitable = false ; return ; } } int dist0 = CircularIndex . distanceP ( e0 . object . index , resultsA . index , contour . size ( ) ) ; if ( dist0 < minimumSideLength || ( contour . size ( ) - dist0 ) < minimumSideLength ) { throw new RuntimeException ( "Should be impossible" ) ; } e0 . object . splitLocation = resultsA . index ; e0 . object . splitError0 = computeSideError ( contour , e0 . object . index , resultsA . index ) ; e0 . object . splitError1 = computeSideError ( contour , resultsA . index , e1 . object . index ) ; if ( e0 . object . splitLocation >= contour . size ( ) ) throw new RuntimeException ( "Egads" ) ; } | Selects and splits the side defined by the e0 corner . If convex a check is performed to ensure that the polyline will be convex still . |
26,650 | boolean canBeSplit ( List < Point2D_I32 > contour , Element < Corner > e0 , boolean mustSplit ) { Element < Corner > e1 = next ( e0 ) ; int length = CircularIndex . distanceP ( e0 . object . index , e1 . object . index , contour . size ( ) ) ; if ( length <= 2 * minimumSideLength ) { return false ; } return mustSplit || e0 . object . sideError > thresholdSideSplitScore ; } | Determines if the side can be split again . A side can always be split as long as it s &ge ; the minimum length or that the side score is larger the the split threshold |
26,651 | Element < Corner > next ( Element < Corner > e ) { if ( e . next == null ) { return list . getHead ( ) ; } else { return e . next ; } } | Returns the next corner in the list |
26,652 | Element < Corner > previous ( Element < Corner > e ) { if ( e . previous == null ) { return list . getTail ( ) ; } else { return e . previous ; } } | Returns the previous corner in the list |
26,653 | 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 ; } | Using double prevision here instead of int due to fear of overflow in very large images |
26,654 | 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 ; } | Assigns the line so that it passes through points A and B . |
26,655 | protected void splitPixels ( int indexStart , int indexStop ) { if ( indexStart + 1 >= indexStop ) return ; int indexSplit = selectSplitBetween ( indexStart , indexStop ) ; if ( indexSplit >= 0 ) { splitPixels ( indexStart , indexSplit ) ; splits . add ( indexSplit ) ; splitPixels ( indexSplit , indexStop ) ; } } | Recursively splits pixels . Used in the initial segmentation . Only split points between the two ends are added |
26,656 | 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 ( bestIndex ) ; } else { work . add ( start ) ; } } work . add ( splits . data [ splits . size - 1 ] ) ; GrowQueue_I32 tmp = work ; work = splits ; splits = tmp ; return change ; } | Splits a line in two if there is a paint that is too far away |
26,657 | protected boolean mergeSegments ( ) { if ( splits . size <= 2 ) return false ; boolean change = false ; work . reset ( ) ; work . add ( splits . data [ 0 ] ) ; for ( int i = 0 ; i < splits . size - 2 ; i ++ ) { if ( selectSplitBetween ( splits . data [ i ] , splits . data [ i + 2 ] ) < 0 ) { change = true ; } else { work . add ( splits . data [ i + 1 ] ) ; } } work . add ( splits . data [ splits . size - 1 ] ) ; GrowQueue_I32 tmp = work ; work = splits ; splits = tmp ; return change ; } | Merges lines together which have an acute angle less than the threshold . |
26,658 | 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 < image . getNumLayers ( ) ; i ++ ) { gradient . process ( image . getLayer ( i ) , previousDerivX [ i ] , previousDerivY [ i ] ) ; } previousImage . setTo ( image ) ; } | Call for the first image being tracked |
26,659 | 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 . getNumLayers ( ) ) ; currentDerivY = ( D [ ] ) Array . newInstance ( derivType , image . getNumLayers ( ) ) ; for ( int i = 0 ; i < image . getNumLayers ( ) ; i ++ ) { int w = image . getWidth ( i ) ; int h = image . getHeight ( i ) ; previousDerivX [ i ] = GeneralizedImageOps . createSingleBand ( derivType , w , h ) ; previousDerivY [ i ] = GeneralizedImageOps . createSingleBand ( derivType , w , h ) ; currentDerivX [ i ] = GeneralizedImageOps . createSingleBand ( derivType , w , h ) ; currentDerivY [ i ] = GeneralizedImageOps . createSingleBand ( derivType , w , h ) ; } Class imageClass = image . getImageType ( ) . getImageClass ( ) ; previousImage = FactoryPyramid . discreteGaussian ( image . getScales ( ) , - 1 , 1 , false , ImageType . single ( imageClass ) ) ; previousImage . initialize ( image . getInputWidth ( ) , image . getInputHeight ( ) ) ; for ( int i = 0 ; i < tracks . length ; i ++ ) { Track t = new Track ( ) ; t . klt = new PyramidKltFeature ( numPyramidLayers , featureRadius ) ; tracks [ i ] = t ; } } | Declares internal data structures based on the input image pyramid |
26,660 | public boolean process ( ImagePyramid < I > image , Rectangle2D_F64 targetRectangle ) { boolean success = true ; updateCurrent ( image ) ; spawnGrid ( targetRectangle ) ; if ( ! trackFeature ( ) ) success = false ; setCurrentToPrevious ( ) ; return success ; } | Creates several tracks inside the target rectangle and compuets their motion |
26,661 | 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 ] ) ; } } | Computes the gradient and changes the reference to the current pyramid |
26,662 | protected void spawnGrid ( Rectangle2D_F64 prevRect ) { 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 - featureRadius ; double spawnWidth = spawnRect . getWidth ( ) ; double spawnHeight = spawnRect . getHeight ( ) ; tracker . setImage ( previousImage , previousDerivX , previousDerivY ) ; for ( int i = 0 ; i < gridWidth ; i ++ ) { float y = ( float ) ( spawnRect . p0 . y + i * spawnHeight / ( gridWidth - 1 ) ) ; for ( int j = 0 ; j < gridWidth ; j ++ ) { float x = ( float ) ( spawnRect . p0 . x + j * spawnWidth / ( gridWidth - 1 ) ) ; Track t = tracks [ i * gridWidth + j ] ; t . klt . x = x ; t . klt . y = y ; if ( tracker . setDescription ( t . klt ) ) { t . active = true ; } else { t . active = false ; } } } } | Spawn KLT tracks at evenly spaced points inside a grid |
26,663 | public boolean process ( T left , T right ) { if ( first ) { associateL2R ( left , right ) ; first = false ; } else { associateL2R ( left , right ) ; associateF2F ( ) ; cyclicConsistency ( ) ; if ( ! estimateMotion ( ) ) return false ; } return true ; } | Estimates camera egomotion from the stereo pair |
26,664 | private void associateL2R ( T left , T right ) { ImageInfo < TD > tmp = featsLeft1 ; featsLeft1 = featsLeft0 ; featsLeft0 = tmp ; tmp = featsRight1 ; featsRight1 = featsRight0 ; featsRight0 = tmp ; featsLeft1 . reset ( ) ; featsRight1 . reset ( ) ; describeImage ( left , featsLeft1 ) ; describeImage ( right , featsRight1 ) ; for ( int i = 0 ; i < detector . getNumberOfSets ( ) ; i ++ ) { SetMatches matches = setMatches [ i ] ; matches . swap ( ) ; matches . match2to3 . reset ( ) ; FastQueue < Point2D_F64 > leftLoc = featsLeft1 . location [ i ] ; FastQueue < Point2D_F64 > rightLoc = featsRight1 . location [ i ] ; assocL2R . setSource ( leftLoc , featsLeft1 . description [ i ] ) ; assocL2R . setDestination ( rightLoc , featsRight1 . description [ i ] ) ; assocL2R . associate ( ) ; FastQueue < AssociatedIndex > found = assocL2R . getMatches ( ) ; setMatches ( matches . match2to3 , found , leftLoc . size ) ; } } | Associates image features from the left and right camera together while applying epipolar constraints . |
26,665 | private void associateF2F ( ) { quadViews . reset ( ) ; for ( int i = 0 ; i < detector . getNumberOfSets ( ) ; i ++ ) { SetMatches matches = setMatches [ i ] ; assocSame . setSource ( featsLeft0 . location [ i ] , featsLeft0 . description [ i ] ) ; assocSame . setDestination ( featsLeft1 . location [ i ] , featsLeft1 . description [ i ] ) ; assocSame . associate ( ) ; setMatches ( matches . match0to2 , assocSame . getMatches ( ) , featsLeft0 . location [ i ] . size ) ; assocSame . setSource ( featsRight0 . location [ i ] , featsRight0 . description [ i ] ) ; assocSame . setDestination ( featsRight1 . location [ i ] , featsRight1 . description [ i ] ) ; assocSame . associate ( ) ; setMatches ( matches . match1to3 , assocSame . getMatches ( ) , featsRight0 . location [ i ] . size ) ; } } | Associates images between left and left and right and right images |
26,666 | 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 ] ; SetMatches matches = setMatches [ i ] ; if ( matches . match0to1 . size != matches . match0to2 . size ) throw new RuntimeException ( "Failed sanity check" ) ; for ( int j = 0 ; j < matches . match0to1 . size ; j ++ ) { int indexIn1 = matches . match0to1 . data [ j ] ; int indexIn2 = matches . match0to2 . data [ j ] ; if ( indexIn1 < 0 || indexIn2 < 0 ) continue ; int indexIn3a = matches . match1to3 . data [ indexIn1 ] ; int indexIn3b = matches . match2to3 . data [ indexIn2 ] ; if ( indexIn3a < 0 || indexIn3b < 0 ) continue ; if ( indexIn3a == indexIn3b ) { QuadView v = quadViews . grow ( ) ; v . v0 = obs0 . get ( j ) ; v . v1 = obs1 . get ( indexIn1 ) ; v . v2 = obs2 . get ( indexIn2 ) ; v . v3 = obs3 . get ( indexIn3a ) ; } } } } | Create a list of features which have a consistent cycle of matches 0 - > 1 - > 3 and 0 - > 2 - > 3 |
26,667 | 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 . getNumberOfFeatures ( ) ; j ++ ) { l . grow ( ) . set ( set . getLocation ( j ) ) ; d . grow ( ) . setTo ( set . getDescription ( j ) ) ; } } } | Computes image features and stores the results in info |
26,668 | private boolean estimateMotion ( ) { modelFitData . reset ( ) ; Point2D_F64 normLeft = new Point2D_F64 ( ) ; Point2D_F64 normRight = new Point2D_F64 ( ) ; for ( int i = 0 ; i < quadViews . size ; i ++ ) { QuadView obs = quadViews . get ( i ) ; leftImageToNorm . compute ( obs . v0 . x , obs . v0 . y , normLeft ) ; rightImageToNorm . compute ( obs . v1 . x , obs . v1 . y , normRight ) ; triangulate . triangulate ( normLeft , normRight , leftToRight , obs . X ) ; if ( ! Double . isInfinite ( obs . X . normSq ( ) ) ) { Stereo2D3D data = modelFitData . grow ( ) ; leftImageToNorm . compute ( obs . v2 . x , obs . v2 . y , data . leftObs ) ; rightImageToNorm . compute ( obs . v3 . x , obs . v3 . y , data . rightObs ) ; data . location . set ( obs . X ) ; } } if ( ! matcher . process ( modelFitData . toList ( ) ) ) return false ; Se3_F64 oldToNew = matcher . getModelParameters ( ) ; if ( modelRefiner != null ) { Se3_F64 found = new Se3_F64 ( ) ; if ( modelRefiner . fitModel ( matcher . getMatchSet ( ) , oldToNew , found ) ) { found . invert ( newToOld ) ; } else { oldToNew . invert ( newToOld ) ; } } else { oldToNew . invert ( newToOld ) ; } Se3_F64 temp = new Se3_F64 ( ) ; newToOld . concat ( leftCamToWorld , temp ) ; leftCamToWorld . set ( temp ) ; return true ; } | Estimates camera egomotion between the two most recent image frames |
26,669 | public void setEquirectangularShape ( int width , int height ) { super . setEquirectangularShape ( width , height ) ; declareVectors ( width , height ) ; for ( int y = 0 ; y < height ; y ++ ) { for ( int x = 0 ; x < width ; x ++ ) { tools . equiToNormFV ( x , y , vectors [ y * width + x ] ) ; } } } | Specifies the image s width and height |
26,670 | 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 : likelihood = FactoryTrackerObjectAlgs . likelihoodHistogramCoupled ( maxPixelValue , numBins , imageType ) ; break ; case HISTOGRAM_INDEPENDENT_RGB_to_HSV : if ( imageType . getNumBands ( ) != 3 ) throw new IllegalArgumentException ( "Expected RGB image as input with 3-bands" ) ; likelihood = FactoryTrackerObjectAlgs . likelihoodHueSatHistIndependent ( maxPixelValue , numBins , ( ImageType ) imageType ) ; break ; case HISTOGRAM_RGB_to_HSV : if ( imageType . getNumBands ( ) != 3 ) throw new IllegalArgumentException ( "Expected RGB image as input with 3-bands" ) ; likelihood = FactoryTrackerObjectAlgs . likelihoodHueSatHistCoupled ( maxPixelValue , numBins , ( ImageType ) imageType ) ; break ; default : throw new IllegalArgumentException ( "Unknown likelihood model " + modelType ) ; } TrackerMeanShiftLikelihood < T > alg = new TrackerMeanShiftLikelihood < > ( likelihood , maxIterations , 0.1f ) ; return new Msl_to_TrackerObjectQuad < > ( alg , likelihood , imageType ) ; } | Very basic and very fast implementation of mean - shift which uses a fixed sized rectangle for its region . Works best when the target is composed of a single color . |
26,671 | 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 ) ; } | Implementation of mean - shift which matches the histogram and can handle targets composed of multiple colors . The tracker can also be configured to estimate gradual changes in scale . The track region is composed of a rotated rectangle . |
26,672 | public void updateBackground ( T frame , GrayU8 segment ) { updateBackground ( frame ) ; segment ( frame , segment ) ; } | Updates the background and segments it at the same time . In some implementations this can be significantly faster than doing it with separate function calls . Segmentation is performed using the model which it has prior to the update . |
26,673 | 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 + i , ( bits >> i ) & 1 ) ; } } else { for ( int i = 0 ; i < numberOfBits ; i ++ ) { set ( indexTail + numberOfBits - i - 1 , ( bits >> i ) & 1 ) ; } } } | Appends bits on to the end of the stack . |
26,674 | 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" ) ; int output = 0 ; if ( swapOrder ) { for ( int i = 0 ; i < length ; i ++ ) { output |= get ( location + i ) << ( length - i - 1 ) ; } } else { for ( int i = 0 ; i < length ; i ++ ) { output |= get ( location + i ) << i ; } } return output ; } | Read bits from the array and store them in an int |
26,675 | public void growArray ( int amountBits , boolean saveValue ) { size = size + amountBits ; int N = size / 8 + ( size % 8 == 0 ? 0 : 1 ) ; if ( N > data . length ) { int extra = Math . min ( 1024 , N + 10 ) ; byte [ ] tmp = new byte [ N + extra ] ; if ( saveValue ) System . arraycopy ( data , 0 , tmp , 0 , data . length ) ; this . data = tmp ; } } | Increases the size of the data array so that it can store an addition number of bits |
26,676 | protected boolean computeH ( DMatrixRMaj A , DMatrixRMaj H ) { if ( ! solverNullspace . process ( A . copy ( ) , 1 , H ) ) return true ; H . numRows = 3 ; H . numCols = 3 ; return false ; } | Computes the SVD of A and extracts the homography matrix from its null space |
26,677 | 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 . getDDRM ( ) ) ; } | Undoes normalization for a homography matrix . |
26,678 | protected int addConicPairConstraints ( AssociatedPairConic a , AssociatedPairConic b , DMatrixRMaj A , int rowA ) { UtilCurves_F64 . convert ( a . p1 , C1 ) ; UtilCurves_F64 . convert ( a . p2 , V1 ) ; CommonOps_DDF3 . invert ( C1 , C1_inv ) ; CommonOps_DDF3 . invert ( V1 , V1_inv ) ; UtilCurves_F64 . convert ( b . p1 , C2 ) ; UtilCurves_F64 . convert ( b . p2 , V2 ) ; CommonOps_DDF3 . invert ( C2 , C2_inv ) ; CommonOps_DDF3 . invert ( V2 , V2_inv ) ; CommonOps_DDF3 . mult ( V1_inv , V2 , L ) ; CommonOps_DDF3 . mult ( C1_inv , C2 , R ) ; int idxA = rowA * 9 ; for ( int row = 0 ; row < 3 ; row ++ ) { for ( int col = 0 ; col < 3 ; col ++ ) { for ( int i = 0 ; i < 3 ; i ++ ) { A . data [ idxA + 3 * i + col ] += L . get ( row , i ) ; A . data [ idxA + 3 * row + i ] -= R . get ( i , col ) ; } idxA += 9 ; } } return rowA + 9 ; } | Add constraint for a pair of conics |
26,679 | protected void initalize ( T input ) { this . input = input ; pixels . resize ( input . width * input . height ) ; initialSegments . reshape ( input . width , input . height ) ; int numberOfUsable = ( input . width - 2 * BORDER ) * ( input . height - 2 * BORDER ) ; gridInterval = ( int ) Math . sqrt ( numberOfUsable / ( double ) numberOfRegions ) ; if ( gridInterval <= 0 ) throw new IllegalArgumentException ( "Too many regions for an image of this size" ) ; adjustSpacial = m / gridInterval ; } | prepares all data structures |
26,680 | 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 < input . width - BORDER ; x += gridInterval ) { Cluster c = clusters . grow ( ) ; c . id = clusterId ++ ; if ( c . color == null ) c . color = new float [ numBands ] ; perturbCenter ( c , x , y ) ; } } } | initialize all the clusters at regularly spaced intervals . Their locations are perturbed a bit to reduce the likelihood of a bad location . Initial color is set to the image color at the location |
26,681 | 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 ; } } } c . x = x + bestX ; c . y = y + bestY ; setColor ( c . color , x + bestX , y + bestY ) ; } | Set the cluster s center to be the pixel in a 3x3 neighborhood with the smallest gradient |
26,682 | 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 ; } | Computes the gradient at the specified pixel |
26,683 | 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 ] ; int centerX = ( int ) ( c . x + 0.5f ) ; int centerY = ( int ) ( c . y + 0.5f ) ; int x0 = centerX - gridInterval ; int x1 = centerX + gridInterval + 1 ; int y0 = centerY - gridInterval ; int y1 = centerY + gridInterval + 1 ; if ( x0 < 0 ) x0 = 0 ; if ( y0 < 0 ) y0 = 0 ; if ( x1 > input . width ) x1 = input . width ; if ( y1 > input . height ) y1 = input . height ; for ( int y = y0 ; y < y1 ; y ++ ) { int indexPixel = y * input . width + x0 ; int indexInput = input . startIndex + y * input . stride + x0 ; int dy = y - centerY ; for ( int x = x0 ; x < x1 ; x ++ ) { int dx = x - centerX ; float distanceColor = colorDistance ( c . color , indexInput ++ ) ; float distanceSpacial = dx * dx + dy * dy ; pixels . data [ indexPixel ++ ] . add ( c , distanceColor + adjustSpacial * distanceSpacial ) ; } } } } | Computes how far away each cluster is from each pixel . Expectation step . |
26,684 | 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 ++ ) { Pixel p = pixels . get ( indexPixel ) ; p . computeWeights ( ) ; for ( int i = 0 ; i < p . clusters . size ; i ++ ) { ClusterDistance d = p . clusters . data [ i ] ; d . cluster . x += x * d . distance ; d . cluster . y += y * d . distance ; d . cluster . totalWeight += d . distance ; addColor ( d . cluster . color , indexInput , d . distance ) ; } } } for ( int i = 0 ; i < clusters . size ; i ++ ) { clusters . data [ i ] . update ( ) ; } } | Update the value of each cluster using Maximization step . |
26,685 | 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 < numBands ; j ++ ) { r [ j ] = c [ j ] ; } } regionMemberCount . resize ( clusters . size ( ) ) ; regionMemberCount . fill ( 0 ) ; int indexPixel = 0 ; for ( int y = 0 ; y < pixelToRegions . height ; y ++ ) { int indexOutput = pixelToRegions . startIndex + y * pixelToRegions . stride ; for ( int x = 0 ; x < pixelToRegions . width ; x ++ , indexPixel ++ , indexOutput ++ ) { Pixel p = pixels . data [ indexPixel ] ; int best = - 1 ; float bestDistance = Float . MAX_VALUE ; for ( int j = 0 ; j < p . clusters . size ; j ++ ) { ClusterDistance d = p . clusters . data [ j ] ; if ( d . distance < bestDistance ) { bestDistance = d . distance ; best = d . cluster . id ; } } if ( best == - 1 ) { regionColor . grow ( ) ; best = regionMemberCount . size ( ) ; regionMemberCount . add ( 0 ) ; } pixelToRegions . data [ indexOutput ] = best ; regionMemberCount . data [ best ] ++ ; } } } | Selects which region each pixel belongs to based on which cluster it is the closest to |
26,686 | 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 ) ; SimpleMatrix R = rotateEpipole ( epipole2 , centerX , centerY ) ; SimpleMatrix T = translateToOrigin ( centerX , centerY ) ; SimpleMatrix G = computeG ( epipole2 , centerX , centerY ) ; SimpleMatrix H = G . mult ( R ) . mult ( T ) ; SimpleMatrix Hzero = computeHZero ( F , epipole2 , H ) ; SimpleMatrix Ha = computeAffineH ( observations , H . getDDRM ( ) , Hzero . getDDRM ( ) ) ; rect1 . set ( Ha . mult ( Hzero ) . getDDRM ( ) ) ; rect2 . set ( H . getDDRM ( ) ) ; } | Compute rectification transforms for the stereo pair given a fundamental matrix and its observations . |
26,687 | 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 inside the image" ) ; if ( x2 >= 0 && x2 < width && y2 >= 0 && y2 < height ) throw new IllegalArgumentException ( "Second epipole is inside the image" ) ; } | The epipoles need to be outside the image |
26,688 | private SimpleMatrix translateToOrigin ( int x0 , int y0 ) { SimpleMatrix T = SimpleMatrix . identity ( 3 ) ; T . set ( 0 , 2 , - x0 ) ; T . set ( 1 , 2 , - y0 ) ; return T ; } | Create a transform which will move the specified point to the origin |
26,689 | 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 ( int i = 0 ; i < observations . size ( ) ; i ++ ) { AssociatedPair a = observations . get ( i ) ; GeometryMath_F64 . mult ( Hzero , a . p1 , k ) ; GeometryMath_F64 . mult ( H , a . p2 , c ) ; A . setRow ( i , 0 , k . x , k . y , 1 ) ; b . set ( i , 0 , c . x ) ; } SimpleMatrix x = A . solve ( b ) ; SimpleMatrix Ha = SimpleMatrix . identity ( 3 ) ; Ha . setRow ( 0 , 0 , x . getDDRM ( ) . data ) ; return Ha ; } | Finds the values of a b c which minimize |
26,690 | public static URL pathExampleURL ( String path ) { try { File fpath = new File ( path ) ; if ( fpath . isAbsolute ( ) ) return fpath . toURI ( ) . toURL ( ) ; String pathToBase = getPathToBase ( ) ; if ( pathToBase != null ) { File pathExample = new File ( pathToBase , "data/example/" ) ; if ( pathExample . exists ( ) ) { return new File ( pathExample . getPath ( ) , path ) . getAbsoluteFile ( ) . toURL ( ) ; } } URL url = UtilIO . class . getClassLoader ( ) . getResource ( path ) ; if ( url == null ) { System . err . println ( ) ; System . err . println ( "Can't find data/example directory! There are three likely causes for this problem." ) ; System . err . println ( ) ; System . err . println ( "1) You checked out the source code from git and did not pull the data submodule too." ) ; System . err . println ( "2) You are trying to run an example from outside the BoofCV directory tree." ) ; System . err . println ( "3) You are trying to pass in your own image." ) ; System . err . println ( ) ; System . err . println ( "Solutions:" ) ; System . err . println ( "1) Follow instructions in the boofcv/readme.md file to grab the data directory." ) ; System . err . println ( "2) Launch the example from inside BoofCV's directory tree!" ) ; System . err . println ( "3) Don't use this function and just pass in the path directly" ) ; System . exit ( 1 ) ; } return url ; } catch ( MalformedURLException e ) { throw new RuntimeException ( e ) ; } } | Returns an absolute path to the file that is relative to the example directory |
26,691 | 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 ) { try { url = new File ( path ) . toURI ( ) . toURL ( ) ; } catch ( MalformedURLException e2 ) { return null ; } } return url ; } | Given a path which may or may not be a URL return a URL |
26,692 | 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 ; } } | Jar paths don t work if they include up directory . this wills trip those out . |
26,693 | public static String path ( String path ) { String pathToBase = getPathToBase ( ) ; if ( pathToBase == null ) return path ; return new File ( pathToBase , path ) . getAbsolutePath ( ) ; } | Searches for the root BoofCV directory and returns an absolute path from it . |
26,694 | 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 ; boolean foundIntegration = false ; for ( String s : files ) { if ( s . compareToIgnoreCase ( "main" ) == 0 ) foundMain = true ; else if ( s . compareToIgnoreCase ( "examples" ) == 0 ) foundExamples = true ; else if ( s . compareToIgnoreCase ( "integration" ) == 0 ) foundIntegration = true ; } if ( foundMain && foundExamples && foundIntegration ) return path ; path = f . getParent ( ) ; } return null ; } | Steps back until it finds the base BoofCV directory . |
26,695 | 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 ) ; } return fileName ; } | Opens up a dialog box asking the user to select a file . If the user cancels it either returns null or quits the program . |
26,696 | 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 ( ) ) ; } else if ( url . getProtocol ( ) . equals ( "jar" ) ) { return listJarPrefix ( url , prefix , suffix ) ; } } catch ( MalformedURLException ignore ) { } } if ( ! d . isDirectory ( ) ) throw new IllegalArgumentException ( "Must specify an directory. " + directory ) ; File files [ ] = d . listFiles ( ) ; for ( File f : files ) { if ( f . isDirectory ( ) || f . isHidden ( ) ) continue ; if ( prefix == null || f . getName ( ) . startsWith ( prefix ) ) { if ( suffix == null || f . getName ( ) . endsWith ( suffix ) ) { ret . add ( f . getAbsolutePath ( ) ) ; } } } return ret ; } | Loads a list of files with the specified prefix . |
26,697 | public static List < String > listAllMime ( String directory , String type ) { List < String > ret = new ArrayList < > ( ) ; try { URL url = new URL ( directory ) ; if ( url . getProtocol ( ) . equals ( "file" ) ) { directory = url . getFile ( ) ; } else if ( url . getProtocol ( ) . equals ( "jar" ) ) { return listJarMime ( url , null , null ) ; } else { throw new RuntimeException ( "Not sure what to do with this url. " + url . toString ( ) ) ; } } catch ( MalformedURLException ignore ) { } File d = new File ( directory ) ; if ( ! d . isDirectory ( ) ) throw new IllegalArgumentException ( "Must specify an directory" ) ; File [ ] files = d . listFiles ( ) ; if ( files == null ) return ret ; for ( File f : files ) { if ( f . isDirectory ( ) ) continue ; try { String mimeType = Files . probeContentType ( f . toPath ( ) ) ; if ( mimeType . contains ( type ) ) ret . add ( f . getAbsolutePath ( ) ) ; } catch ( IOException ignore ) { } } Collections . sort ( ret ) ; return ret ; } | Lists all files in the directory with an MIME type that contains the string type |
26,698 | public boolean process ( CameraPinholeBrown intrinsic , Se3_F64 planeToCamera ) { proj . setPlaneToCamera ( planeToCamera , true ) ; proj . setIntrinsic ( intrinsic ) ; double x0 = Double . MAX_VALUE ; double y0 = Double . MAX_VALUE ; double x1 = - Double . MAX_VALUE ; double y1 = - Double . MAX_VALUE ; for ( int y = 0 ; y < intrinsic . height ; y ++ ) { for ( int x = 0 ; x < intrinsic . width ; x ++ ) { if ( ! checkValidPixel ( x , y ) ) continue ; if ( plane0 . x < x0 ) x0 = plane0 . x ; if ( plane0 . x > x1 ) x1 = plane0 . x ; if ( plane0 . y < y0 ) y0 = plane0 . y ; if ( plane0 . y > y1 ) y1 = plane0 . y ; } } if ( x0 == Double . MAX_VALUE ) return false ; double mapWidth = x1 - x0 ; double mapHeight = y1 - y0 ; overheadWidth = ( int ) Math . floor ( mapWidth / cellSize ) ; overheadHeight = ( int ) Math . floor ( mapHeight * viewHeightFraction / cellSize ) ; centerX = - x0 ; centerY = - ( y0 + mapHeight * ( 1 - viewHeightFraction ) / 2.0 ) ; return true ; } | Computes the view s characteristics |
26,699 | 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 ; } | Creates a new instance of the overhead view |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.