content: //
  // This file is auto-generated. Please don't modify it!
  //
  package org.opencv.features2d;
  
  
  
  // C++: class Params
  
  public class Params {
  
      protected final long nativeObj;
      protected Params(long addr) { nativeObj = addr; }
  
      public long getNativeObjAddr() { return nativeObj; }
  
      // internal usage only
      public static Params __fromPtr__(long addr) { return new Params(addr); }
  
      //
      // C++:   cv::SimpleBlobDetector::Params::Params()
      //
  
      public Params() {
          nativeObj = Params_0();
      }
  
  
      //
      // C++: float Params::thresholdStep
      //
  
      public float get_thresholdStep() {
          return get_thresholdStep_0(nativeObj);
      }
  
  
      //
      // C++: void Params::thresholdStep
      //
  
      public void set_thresholdStep(float thresholdStep) {
          set_thresholdStep_0(nativeObj, thresholdStep);
      }
  
  
      //
      // C++: float Params::minThreshold
      //
  
      public float get_minThreshold() {
          return get_minThreshold_0(nativeObj);
      }
  
  
      //
      // C++: void Params::minThreshold
      //
  
      public void set_minThreshold(float minThreshold) {
          set_minThreshold_0(nativeObj, minThreshold);
      }
  
  
      //
      // C++: float Params::maxThreshold
      //
  
      public float get_maxThreshold() {
          return get_maxThreshold_0(nativeObj);
      }
  
  
      //
      // C++: void Params::maxThreshold
      //
  
      public void set_maxThreshold(float maxThreshold) {
          set_maxThreshold_0(nativeObj, maxThreshold);
      }
  
  
      //
      // C++: size_t Params::minRepeatability
      //
  
      public long get_minRepeatability() {
          return get_minRepeatability_0(nativeObj);
      }
  
  
      //
      // C++: void Params::minRepeatability
      //
  
      public void set_minRepeatability(long minRepeatability) {
          set_minRepeatability_0(nativeObj, minRepeatability);
      }
  
  
      //
      // C++: float Params::minDistBetweenBlobs
      //
  
      public float get_minDistBetweenBlobs() {
          return get_minDistBetweenBlobs_0(nativeObj);
      }
  
  
      //
      // C++: void Params::minDistBetweenBlobs
      //
  
      public void set_minDistBetweenBlobs(float minDistBetweenBlobs) {
          set_minDistBetweenBlobs_0(nativeObj, minDistBetweenBlobs);
      }
  
  
      //
      // C++: bool Params::filterByColor
      //
  
      public boolean get_filterByColor() {
          return get_filterByColor_0(nativeObj);
      }
  
  
      //
      // C++: void Params::filterByColor
      //
  
      public void set_filterByColor(boolean filterByColor) {
          set_filterByColor_0(nativeObj, filterByColor);
      }
  
  
      //
      // C++: uchar Params::blobColor
      //
  
      // Return type 'uchar' is not supported, skipping the function
  
  
      //
      // C++: void Params::blobColor
      //
  
      // Unknown type 'uchar' (I), skipping the function
  
  
      //
      // C++: bool Params::filterByArea
      //
  
      public boolean get_filterByArea() {
          return get_filterByArea_0(nativeObj);
      }
  
  
      //
      // C++: void Params::filterByArea
      //
  
      public void set_filterByArea(boolean filterByArea) {
          set_filterByArea_0(nativeObj, filterByArea);
      }
  
  
      //
      // C++: float Params::minArea
      //
  
      public float get_minArea() {
          return get_minArea_0(nativeObj);
      }
  
  
      //
      // C++: void Params::minArea
      //
  
      public void set_minArea(float minArea) {
          set_minArea_0(nativeObj, minArea);
      }
  
  
      //
      // C++: float Params::maxArea
      //
  
      public float get_maxArea() {
          return get_maxArea_0(nativeObj);
      }
  
  
      //
      // C++: void Params::maxArea
      //
  
      public void set_maxArea(float maxArea) {
          set_maxArea_0(nativeObj, maxArea);
      }
  
  
      //
      // C++: bool Params::filterByCircularity
      //
  
      public boolean get_filterByCircularity() {
          return get_filterByCircularity_0(nativeObj);
      }
  
  
      //
      // C++: void Params::filterByCircularity
      //
  
      public void set_filterByCircularity(boolean filterByCircularity) {
          set_filterByCircularity_0(nativeObj, filterByCircularity);
      }
  
  
      //
      // C++: float Params::minCircularity
      //
  
      public float get_minCircularity() {
          return get_minCircularity_0(nativeObj);
      }
  
  
      //
      // C++: void Params::minCircularity
      //
  
      public void set_minCircularity(float minCircularity) {
          set_minCircularity_0(nativeObj, minCircularity);
      }
  
  
      //
      // C++: float Params::maxCircularity
      //
  
      public float get_maxCircularity() {
          return get_maxCircularity_0(nativeObj);
      }
  
  
      //
      // C++: void Params::maxCircularity
      //
  
      public void set_maxCircularity(float maxCircularity) {
          set_maxCircularity_0(nativeObj, maxCircularity);
      }
  
  
      //
      // C++: bool Params::filterByInertia
      //
  
      public boolean get_filterByInertia() {
          return get_filterByInertia_0(nativeObj);
      }
  
  
      //
      // C++: void Params::filterByInertia
      //
  
      public void set_filterByInertia(boolean filterByInertia) {
          set_filterByInertia_0(nativeObj, filterByInertia);
      }
  
  
      //
      // C++: float Params::minInertiaRatio
      //
  
      public float get_minInertiaRatio() {
          return get_minInertiaRatio_0(nativeObj);
      }
  
  
      //
      // C++: void Params::minInertiaRatio
      //
  
      public void set_minInertiaRatio(float minInertiaRatio) {
          set_minInertiaRatio_0(nativeObj, minInertiaRatio);
      }
  
  
      //
      // C++: float Params::maxInertiaRatio
      //
  
      public float get_maxInertiaRatio() {
          return get_maxInertiaRatio_0(nativeObj);
      }
  
  
      //
      // C++: void Params::maxInertiaRatio
      //
  
      public void set_maxInertiaRatio(float maxInertiaRatio) {
          set_maxInertiaRatio_0(nativeObj, maxInertiaRatio);
      }
  
  
      //
      // C++: bool Params::filterByConvexity
      //
  
      public boolean get_filterByConvexity() {
          return get_filterByConvexity_0(nativeObj);
      }
  
  
      //
      // C++: void Params::filterByConvexity
      //
  
      public void set_filterByConvexity(boolean filterByConvexity) {
          set_filterByConvexity_0(nativeObj, filterByConvexity);
      }
  
  
      //
      // C++: float Params::minConvexity
      //
  
      public float get_minConvexity() {
          return get_minConvexity_0(nativeObj);
      }
  
  
      //
      // C++: void Params::minConvexity
      //
  
      public void set_minConvexity(float minConvexity) {
          set_minConvexity_0(nativeObj, minConvexity);
      }
  
  
      //
      // C++: float Params::maxConvexity
      //
  
      public float get_maxConvexity() {
          return get_maxConvexity_0(nativeObj);
      }
  
  
      //
      // C++: void Params::maxConvexity
      //
  
      public void set_maxConvexity(float maxConvexity) {
          set_maxConvexity_0(nativeObj, maxConvexity);
      }
  
  
      @Override
      protected void finalize() throws Throwable {
          delete(nativeObj);
      }
  
  
  
      // C++:   cv::SimpleBlobDetector::Params::Params()
      private static native long Params_0();
  
      // C++: float Params::thresholdStep
      private static native float get_thresholdStep_0(long nativeObj);
  
      // C++: void Params::thresholdStep
      private static native void set_thresholdStep_0(long nativeObj, float thresholdStep);
  
      // C++: float Params::minThreshold
      private static native float get_minThreshold_0(long nativeObj);
  
      // C++: void Params::minThreshold
      private static native void set_minThreshold_0(long nativeObj, float minThreshold);
  
      // C++: float Params::maxThreshold
      private static native float get_maxThreshold_0(long nativeObj);
  
      // C++: void Params::maxThreshold
      private static native void set_maxThreshold_0(long nativeObj, float maxThreshold);
  
      // C++: size_t Params::minRepeatability
      private static native long get_minRepeatability_0(long nativeObj);
  
      // C++: void Params::minRepeatability
      private static native void set_minRepeatability_0(long nativeObj, long minRepeatability);
  
      // C++: float Params::minDistBetweenBlobs
      private static native float get_minDistBetweenBlobs_0(long nativeObj);
  
      // C++: void Params::minDistBetweenBlobs
      private static native void set_minDistBetweenBlobs_0(long nativeObj, float minDistBetweenBlobs);
  
      // C++: bool Params::filterByColor
      private static native boolean get_filterByColor_0(long nativeObj);
  
      // C++: void Params::filterByColor
      private static native void set_filterByColor_0(long nativeObj, boolean filterByColor);
  
      // C++: bool Params::filterByArea
      private static native boolean get_filterByArea_0(long nativeObj);
  
      // C++: void Params::filterByArea
      private static native void set_filterByArea_0(long nativeObj, boolean filterByArea);
  
      // C++: float Params::minArea
      private static native float get_minArea_0(long nativeObj);
  
      // C++: void Params::minArea
      private static native void set_minArea_0(long nativeObj, float minArea);
  
      // C++: float Params::maxArea
      private static native float get_maxArea_0(long nativeObj);
  
      // C++: void Params::maxArea
      private static native void set_maxArea_0(long nativeObj, float maxArea);
  
      // C++: bool Params::filterByCircularity
      private static native boolean get_filterByCircularity_0(long nativeObj);
  
      // C++: void Params::filterByCircularity
      private static native void set_filterByCircularity_0(long nativeObj, boolean filterByCircularity);
  
      // C++: float Params::minCircularity
      private static native float get_minCircularity_0(long nativeObj);
  
      // C++: void Params::minCircularity
      private static native void set_minCircularity_0(long nativeObj, float minCircularity);
  
      // C++: float Params::maxCircularity
      private static native float get_maxCircularity_0(long nativeObj);
  
      // C++: void Params::maxCircularity
      private static native void set_maxCircularity_0(long nativeObj, float maxCircularity);
  
      // C++: bool Params::filterByInertia
      private static native boolean get_filterByInertia_0(long nativeObj);
  
      // C++: void Params::filterByInertia
      private static native void set_filterByInertia_0(long nativeObj, boolean filterByInertia);
  
      // C++: float Params::minInertiaRatio
      private static native float get_minInertiaRatio_0(long nativeObj);
  
      // C++: void Params::minInertiaRatio
      private static native void set_minInertiaRatio_0(long nativeObj, float minInertiaRatio);
  
      // C++: float Params::maxInertiaRatio
      private static native float get_maxInertiaRatio_0(long nativeObj);
  
      // C++: void Params::maxInertiaRatio
      private static native void set_maxInertiaRatio_0(long nativeObj, float maxInertiaRatio);
  
      // C++: bool Params::filterByConvexity
      private static native boolean get_filterByConvexity_0(long nativeObj);
  
      // C++: void Params::filterByConvexity
      private static native void set_filterByConvexity_0(long nativeObj, boolean filterByConvexity);
  
      // C++: float Params::minConvexity
      private static native float get_minConvexity_0(long nativeObj);
  
      // C++: void Params::minConvexity
      private static native void set_minConvexity_0(long nativeObj, float minConvexity);
  
      // C++: float Params::maxConvexity
      private static native float get_maxConvexity_0(long nativeObj);
  
      // C++: void Params::maxConvexity
      private static native void set_maxConvexity_0(long nativeObj, float maxConvexity);
  
      // native support for java finalize()
      private static native void delete(long nativeObj);
  
  }
  