Package boofcv.alg.fiducial.calib.ecocheck

Class ECoCheckUtils

java.lang.Object
boofcv.alg.fiducial.calib.ecocheck.ECoCheckUtils
public class ECoCheckUtils extends Object

Common functions that are needed for encoding, decoding, and detecting. Terminology can be found in ECoCheckGenerator.

  • Field Details

    • dataBitWidthFraction

      public double dataBitWidthFraction
      Fraction of a bit-cell's length that the black square is drawn in

    • dataBorderFraction

      public double dataBorderFraction
      Fraction length of the quite-zone around data bits

    • markers

      public final List<GridShape> markers
      Shape of all possible markers

    • bitSampleGridSize

      public int bitSampleGridSize
      Length of the row/column in the grid it will sample when determining a cell's bit value

    • bitSampleCount

      protected int bitSampleCount
      Number of samples it will do for each bit. Each sample is one vote. Dynamically computed from bitSampleGridSize

    • codec

      public final ECoCheckCodec codec
      Used to encode and decode bit streams with coordinate information

    • bitOrder

      public final DogArray_I32 bitOrder
      How bits are ordered. This is done to make bits which are in the same word spatially close to each other

  • Constructor Details

    • ECoCheckUtils

      public ECoCheckUtils()

  • Method Details

    • setParametersFromConfig

      public void setParametersFromConfig(ConfigECoCheckMarkers config)
      Assign all parameters from a config class as possible

    • addMarker

      public void addMarker(int squareRows, int squareCols)
      Adds a new marker to the list
      Parameters:
      squareRows - Number of square rows in the chessboard pattern
      squareCols - Number of square columns in the chessboard pattern

    • fixate

      public void fixate()
      Call after its done being configured so that it can precompute everything that's needed

    • checkFixate

      public void checkFixate()

    • bitRect

      public void bitRect(int row, int col, Rectangle2D_F64 rect)
      Returns the rectangle in which a data-bit will be written to. The rectangle will be in data-region coordinates.
      Parameters:
      row - Bit's row
      col - Bit's column
      rect - (Output) Rectangle containing the bit

    • computeGridToImage

      public boolean computeGridToImage(Point2D_F64 a, Point2D_F64 b, Point2D_F64 c, Point2D_F64 d)
      Finds the correspondence from data-region coordinates to image pixels
      Parameters:
      a - Pixel corresponding to (0,0)
      b - Pixel corresponding to (w,0)
      c - Pixel corresponding to (w,w)
      d - Pixel corresponding to (0,w)

    • otsuThreshold

      public float otsuThreshold(DogArray_F32 values)
      Computes a threshold using Otsu. Assumes that there are two clear peaks in the data.

    • gridToPixel

      public void gridToPixel(double x, double y, Point2D_F64 pixel)
      Convenience function to go from a point in grid coordinates to image pixels

    • selectPixelsToSample

      public void selectPixelsToSample(DogArray<Point2D_F64> pixels)
      Selects pixels that it should sample for each bit. The number of pixels per bit is specified by pixelsPerBit. The order of bits is in row-major format with a block of size bitSampleCount. Points are sampled in a grid pattern with one point in the center. This means there will be an odd number of points preventing a tie.
      Parameters:
      pixels - (Output) Image pixels that correspond pixels in binary version of grid

    • cellIdToCornerCoordinate

      public void cellIdToCornerCoordinate(int markerID, int cellID, GridCoordinate coordinate)
      Given the markerID and cellID, compute the coordinate of the top left corner.
      Parameters:
      markerID - (Input) Marker
      cellID - (Input) Encoded cell ID
      coordinate - (Output) Corner coordinate in corner grid of TL corner

    • adjustTopLeft

      public static void adjustTopLeft(int orientation, GridCoordinate coordinate)
      Adjust the top left corner based on orientation

    • countEncodedSquaresInMarker

      public int countEncodedSquaresInMarker(int markerID)
      Returns the number of encoded cells in the chessboard
      Parameters:
      markerID - (Input) which marker

    • cornerToMarker3D

      public void cornerToMarker3D(int markerID, int cornerID, Point3D_F64 coordinate)
      Converts a corner ID into a marker ID. The origin of the marker's coordinate system will be the marker's center. Coordinates will range from -0.5 to 0.5. The length of the longest side will be 1.0.
      Parameters:
      markerID - Which marker
      cornerID - Which corner
      coordinate - (Output) Coordinate in the coordinate system described above

    • cornerToMarker3D

      public void cornerToMarker3D(int markerID, int cornerID, double squareLength, Point3D_F64 coordinate)

    • createCornerList

      public List<Point2D_F64> createCornerList(int markerID, double squareLength)
      Creates a list of corners coordinates on the specified marker given the size of a full square
      Parameters:
      markerID - Which marker
      squareLength - Size of a full square
      Returns:
      Location of corners in standard order

    • maxCorners

      public static int maxCorners(int rows, int cols)

    • isLegalCornerIds

      public boolean isLegalCornerIds(ECoCheckFound found)

    • mergeAndRemoveUnknown

      public List<ECoCheckFound> mergeAndRemoveUnknown(List<ECoCheckFound> found)
      Merges detections with the same marker ID into a single detection and removes unknown markers. A naive algorithm is used to merge markers together. First it checks to see if there's a conflict between two markers by them having the same cornerID. If that's good it will select the existing marker with the most corners. If there is no matching marker then a new marker is created.
      Parameters:
      found - Original list of found markers.
      Returns:
      New list of markers.