How to use boofcv.alg.descriptor

public DdaManagerGeneralPoint(EasyGeneralFeatureDetector<I, D> detector,
               DescribeRegionPoint<I, Desc> describe,
               double scale) {
  this.detector = detector;
  this.describe = describe;
  this.scale = scale;
  descriptors = UtilFeature.createQueue(describe,100);
}

@Override
public double score(TupleDesc_F64 a, TupleDesc_F64 b) {
  return DescriptorDistance.sad(a, b);
}

@Override
public double score(TupleDesc_F64 a, TupleDesc_F64 b) {
  return DescriptorDistance.euclideanSq(a, b);
}

@Override
public double score(NccFeature a, NccFeature b) {
  return -DescriptorDistance.ncc(a, b);
}

/**
 * Computes the hamming score between two descriptions.  Larger the number better the fit
 */
protected int hamming(short[] a, short[] b) {
  int distance = 0;
  for (int i = 0; i < a.length; i++) {
    distance += DescriptorDistance.hamming((a[i]&0xFFFF) ^ (b[i]&0xFFFF));
  }
  return distance;
}

@Override
public double score(TupleDesc_F64 a, TupleDesc_F64 b) {
  return DescriptorDistance.euclidean(a,b);
}

@Override
public double score(TupleDesc_F64 a, TupleDesc_F64 b) {
  return -DescriptorDistance.correlation(a, b);
}

@Override
public void convert(TupleDesc_F64 input, TupleDesc_U8 output) {
  ConvertDescriptors.positive(input, output);
}

@Override
public void convert(TupleDesc_F64 input, TupleDesc_S8 output) {
  ConvertDescriptors.real(input, output);
}

public DisparityCalculation(DetectDescribePoint<GrayF32, Desc> detDesc,
              AssociateDescription<Desc> associate ,
              CameraPinholeRadial intrinsic ) {
  this.detDesc = detDesc;
  this.associate = associate;
  this.intrinsic = intrinsic;
  listSrc = UtilFeature.createQueue(detDesc, 10);
  listDst = UtilFeature.createQueue(detDesc, 10);
}

/**
 * Computes the best distance to 'observed' from the candidate list.
 * @param observed Feature being matched
 * @param candidates Set of candidate matches
 * @return score from 0 to 1, where lower is closer
 */
public double distance( NccFeature observed , List<NccFeature> candidates ) {
  double maximum = -Double.MAX_VALUE;
  // The feature which has the best fit will maximize the score
  for( NccFeature f : candidates ) {
    double score = DescriptorDistance.ncc(observed, f);
    if( score > maximum )
      maximum = score;
  }
  return 1-0.5*(maximum + 1);
}

@Override
public double score(TupleDesc_B a, TupleDesc_B b) {
  return DescriptorDistance.hamming(a,b);
}

@Override
public double score(TupleDesc_S8 a, TupleDesc_S8 b) {
  return DescriptorDistance.sad(a, b);
}

@Override
public double score(TupleDesc_F32 a, TupleDesc_F32 b) {
  return DescriptorDistance.euclideanSq(a, b);
}

public AssociationProcessing( DetectDescribePoint<GrayF32,Desc> detDesc ,
               AssociateDescription<Desc> associate  ) {
  super(ImageType.single(GrayF32.class));
  this.detDesc = detDesc;
  this.associate = associate;
  listSrc = UtilFeature.createQueue(detDesc,10);
  listDst = UtilFeature.createQueue(detDesc,10);
}

/**
 * Computes the hamming distance between two binary feature descriptors
 *
 * @param a First variable
 * @param b Second variable
 * @return The hamming distance
 */
public static int hamming( TupleDesc_B a, TupleDesc_B b ) {
  int score = 0;
  final int N = a.data.length;
  for( int i = 0; i < N; i++ ) {
    score += hamming(a.data[i] ^ b.data[i]);
  }
  return score;
}

@Override
public double score(TupleDesc_F32 a, TupleDesc_F32 b) {
  return DescriptorDistance.sad(a, b);
}

public DetectDescribeMultiFusion(DetectorInterestPointMulti<T> detector,
                 OrientationImage<T> orientation,
                 DescribeRegionPoint<T, TD> describe) {
  this.detector = detector;
  this.orientation = orientation;
  this.describe = describe;
  info = new SetInfo[ detector.getNumberOfSets() ];
  for( int i = 0; i < info.length; i++ ) {
    info[i] = new SetInfo<>();
    info[i].descriptors = UtilFeature.createQueue(describe,10);
  }
}

@Override
public double score(TupleDesc_U8 a, TupleDesc_U8 b) {
  return DescriptorDistance.sad(a, b);
}

public DdaManagerGeneralPoint(EasyGeneralFeatureDetector<I, D> detector,
               DescribeRegionPoint<I, Desc> describe,
               double scale) {
  this.detector = detector;
  this.describe = describe;
  this.scale = scale;
  numSets = detector.getDetector().isDetectMinimums() ? 1 : 0;
  numSets += detector.getDetector().isDetectMaximums() ? 1 : 0;
  descriptors = UtilFeature.createQueue(describe,100);
}