Detector for regular grid of circles.  All circles must be entirely inside of the image.

@param config Configuration for target
@return The detector
358114
public static CalibrationDetectorCircleRegularGrid circleRegularGrid( @Nullable ConfigCircleRegularGrid config ,
																		  ConfigGridDimen configGrid ) {
		if( config == null )
			config = new ConfigCircleRegularGrid();
		config.checkValidity();

		return new CalibrationDetectorCircleRegularGrid(config,configGrid);
	}
1244654
@Override
    public Screen createScreen(Config config)
    {
        Check.notNull(config);

        final Screen screen;
        if (config.isWindowed())
        {
            screen = new ScreenWindowedAwt(config);
        }
        else
        {
            screen = new ScreenFullAwt(config);
        }
        return screen;
    }
79927
public static Pattern pattern(AbstractConfig config, String key) {
    String pattern = config.getString(key);

    try {
      return Pattern.compile(pattern);
    } catch (PatternSyntaxException e) {
      throw new ConfigException(
          key,
          pattern,
          String.format(
              "Could not compile regex '%s'.",
              pattern
          )
      );
    }
  }
97641
@NonNull
  public RequestCreator config(@NonNull Bitmap.Config config) {
    data.config(config);
    return this;
  }
98768
@SuppressWarnings({ "rawtypes", "unchecked" })
	protected Object creteObject(NodeConfig config) throws UnmarshalException {
		Object targetObject = null;

		if (rootClass.equals(Map.class)) {
			targetObject = (new MapCreator()).getMap(config);
		} else {
			Class targetClass = rootClass;
			if (targetClass.isAnnotationPresent(Root.class)) {
				targetObject = (new AnnotationObjectCreator(validation)).getObject(config, rootClass, null);
			} else {
				targetObject = (new DefaultObjectCreator(validation)).getObject(config, rootClass, null);
			}

		}

		return targetObject;
	}
1113026
public Point getMotionCog() {
		Point cog = algorithm.getCog();
		if (cog == null) {
			// detectorAlgorithm hasn't been called so far - get image center
			int w = webcam.getViewSize().width;
			int h = webcam.getViewSize().height;
			cog = new Point(w / 2, h / 2);
		}
		return cog;
	}
335888
public static int getPixelSizeForBitmapConfig(Bitmap.Config bitmapConfig) {

    switch (bitmapConfig) {
      case ARGB_8888:
        return ARGB_8888_BYTES_PER_PIXEL;
      case ALPHA_8:
        return ALPHA_8_BYTES_PER_PIXEL;
      case ARGB_4444:
        return ARGB_4444_BYTES_PER_PIXEL;
      case RGB_565:
        return RGB_565_BYTES_PER_PIXEL;
      case RGBA_F16:
        return RGBA_F16_BYTES_PER_PIXEL;
    }
    throw new UnsupportedOperationException("The provided Bitmap.Config is not supported");
  }
483346
public Circle fit(Circle initCircle, DenseMatrix64F points)
    {
        initCenter.data[0] = initCircle.getX();
        initCenter.data[1] = initCircle.getY();
        radius = initCircle.getRadius();
        fit(points);
        return this;
    }
639270
public PackingPlan createPackingPlan(final Config config, final Config runtime)
    throws PackingException {
    // Create an instance of the packing class
    String packingClass = Context.packingClass(config);
    IPacking packing;
    try {
      // create an instance of the packing class
      packing = ReflectionUtils.newInstance(packingClass);
    } catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
      throw new PackingException(String.format(
          "Failed to instantiate packing instance using packing class %s", packingClass), e);
    }

    try {
      TopologyAPI.Topology topology = Runtime.topology(runtime);
      packing.initialize(config, topology);
      return packing.pack();
    } finally {
      SysUtils.closeIgnoringExceptions(packing);
    }
  }
468147
public static ImagePipelineConfig getImagePipelineConfig(Context context) {
    if (sImagePipelineConfig == null) {
      ImagePipelineConfig.Builder configBuilder = ImagePipelineConfig.newBuilder(context);
      configureCaches(configBuilder, context);
      configureLoggingListeners(configBuilder);
      configureOptions(configBuilder);
      sImagePipelineConfig = configBuilder.build();
    }
    return sImagePipelineConfig;
  }
1317345
@Override
    protected FreeMarkerConfig autodetectConfiguration() throws BeansException {
        SiteContext siteContext = SiteContext.getCurrent();
        if (siteContext != null) {
            return siteContext.getFreeMarkerConfig();
        } else {
            return super.autodetectConfiguration();
        }
    }
1047997
function (config) {
			return this.expect.element(this.getPrimaryNavbarSectionElement({ section: config.section })).to.be.visible;
		}
1086802
public ConstraintValidatorFactory getConstraintValidatorFactoryOverride(Configuration<?> config) {
        ValidationReleasable<ConstraintValidatorFactory> releasable = null;

        String cvfClassName = config.getBootstrapConfiguration().getConstraintValidatorFactoryClassName();
        // If the validation.xml ConstraintValidatorFactory is null AND the CDI feature is enabled
        // we can try to create our own implementation of it.
        if (cvfClassName == null && releasableFactory != null) {
            releasable = releasableFactory.createConstraintValidatorFactory();
        }

        if (releasable != null) {
            if (releasables == null) {
                releasables = new LinkedList<ValidationReleasable<?>>();
            }

            releasables.add(releasable);
            return releasable.getInstance();
        }
        return null;
    }
1036633
public static TypesafeConfigModule fromConfigUsingClasspathScanner(Config config, String ...scannerSpec) {
		return new TypesafeConfigModule(config, new FastClasspathScanningReflector(scannerSpec));
	}
1132194
public static <T extends ImageGray<T>>
	DenseOpticalFlow<T> hornSchunckPyramid( @Nullable ConfigHornSchunckPyramid config , Class<T> imageType )
	{
		if( config == null )
			config = new ConfigHornSchunckPyramid();

		InterpolatePixelS<GrayF32> interpolate =
				FactoryInterpolation.createPixelS(0,255,config.interpolation, BorderType.EXTENDED, GrayF32.class);

		HornSchunckPyramid<T> alg = new HornSchunckPyramid<>(config, interpolate);

		return new HornSchunckPyramid_to_DenseOpticalFlow<>(alg, imageType);
	}
703028
public static LazyGauge maxGauge(MonitorConfig config) {
    return new LazyGauge(Registry::maxGauge, registry, createId(config));
  }
418049
public FeatureManagerBuilder togglzConfig(TogglzConfig config) {
        stateRepository(config.getStateRepository());
        featureEnum(config.getFeatureClass());
        userProvider(config.getUserProvider());
        return this;
    }