Creates a dense HOG descriptor.

@see DescribeDenseHogFastAlg
@see DescribeDenseHogAlg

@param config Configuration for HOG descriptor.  Can't be null.
@param imageType Type of input image.  Can be single band or planar
@return Dense HOG extractor
549551
public static <T extends ImageBase<T>>
	DescribeImageDense<T,TupleDesc_F64> hog(@Nullable ConfigDenseHoG config , ImageType<T> imageType ) {
		if( config == null )
			config = new ConfigDenseHoG();

		config.checkValidity();

		ImageType actualType;
		if( imageType.getDataType() != ImageDataType.F32 ) {
			actualType = new ImageType(imageType.getFamily(),ImageDataType.F32,imageType.getNumBands());
		} else {
			actualType = imageType;
		}

		BaseDenseHog hog;
		if( config.fastVariant ) {
			hog = FactoryDescribeImageDenseAlg.hogFast(config, actualType);
		} else {
			hog = FactoryDescribeImageDenseAlg.hog(config, actualType);
		}

		DescribeImageDenseHoG output = new DescribeImageDenseHoG(hog);

		// If the data type isn't F32 convert it into that data type first
		if( actualType != imageType ) {
			return new DescribeImageDense_Convert<>(output, imageType);
		} else {
			return output;
		}
	}
348938
public JawrConfigManagerMBean getConfigMgr(String resourceType) {

		JawrConfigManagerMBean configMgr = null;
		if (resourceType.equals(JS_TYPE)) {
			configMgr = jsMBean;
		} else if (resourceType.equals(CSS_TYPE)) {
			configMgr = cssMBean;
		} else if (resourceType.equals(BINARY_TYPE)) {
			configMgr = binaryMBean;
		}

		return configMgr;
	}
456919
public static <T extends ImageGray<T>>
	DetectDescribePoint<T,BrightFeature> sift( @Nullable ConfigCompleteSift config )
	{
		if( config == null )
			config = new ConfigCompleteSift();

		ConfigSiftScaleSpace configSS = config.scaleSpace;
		ConfigSiftDetector configDetector = config.detector;
		ConfigSiftOrientation configOri = config.orientation;
		ConfigSiftDescribe configDesc = config.describe;

		SiftScaleSpace scaleSpace = new SiftScaleSpace(
				configSS.firstOctave,configSS.lastOctave,configSS.numScales,configSS.sigma0);
		OrientationHistogramSift<GrayF32> orientation = new OrientationHistogramSift<>(
				configOri.histogramSize,configOri.sigmaEnlarge,GrayF32.class);
		DescribePointSift<GrayF32> describe = new DescribePointSift<>(
				configDesc.widthSubregion,configDesc.widthGrid, configDesc.numHistogramBins,
				configDesc.sigmaToPixels, configDesc.weightingSigmaFraction,
				configDesc.maxDescriptorElementValue,GrayF32.class);

		NonMaxSuppression nns = FactoryFeatureExtractor.nonmax(configDetector.extract);
		NonMaxLimiter nonMax = new NonMaxLimiter(nns,configDetector.maxFeaturesPerScale);
		CompleteSift dds = new CompleteSift(scaleSpace,configDetector.edgeR,nonMax,orientation,describe);
		return new DetectDescribe_CompleteSift<>(dds);
	}
1030279
public static <T extends ImageBase<T>> BlurStorageFilter<T> mean(ImageType<T> type , int radius ) {
		return new BlurStorageFilter<>("mean", type, radius);
	}
1088533
public static <T extends ImageBase<T>> BlurStorageFilter<T> median(ImageType<T> type , int radius ) {
		return new BlurStorageFilter<>("median", type, radius);
	}
1080619
public static <T extends ImageGray<T>>
	InputToBinary<T> localGaussian(ConfigLength regionWidth, double scale, boolean down, Class<T> inputType) {
		if( BOverrideFactoryThresholdBinary.localGaussian != null )
			return BOverrideFactoryThresholdBinary.localGaussian.handle(regionWidth, scale, down, inputType);
		return new LocalGaussianBinaryFilter<>(regionWidth, scale, down, ImageType.single(inputType));
	}
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;
  }
868652
public static <T extends ImageGray<T>>
	DenseOpticalFlow<T> region( @Nullable ConfigOpticalFlowBlockPyramid config , Class<T> imageType )
	{
		if( config == null )
			config = new ConfigOpticalFlowBlockPyramid();

		DenseOpticalFlowBlockPyramid<T> alg;
		if( imageType == GrayU8.class )
			alg = (DenseOpticalFlowBlockPyramid)new DenseOpticalFlowBlockPyramid.U8(
					config.searchRadius,config.regionRadius,config.maxPerPixelError);
		else if( imageType == GrayF32.class )
			alg = (DenseOpticalFlowBlockPyramid)new DenseOpticalFlowBlockPyramid.F32(
					config.searchRadius,config.regionRadius,config.maxPerPixelError);
		else
			throw new IllegalArgumentException("Unsupported image type "+imageType);

		return new FlowBlock_to_DenseOpticalFlow<>(alg, config.pyramidScale, config.maxPyramidLayers, imageType);
	}
1053517
public static <T extends ImageBase<T>, II extends ImageGray<II>>
	DescribeRegionPoint<T,BrightFeature> surfColorStable(ConfigSurfDescribe.Stability config, ImageType<T> imageType) {

		Class bandType = imageType.getImageClass();
		Class<II> integralType = GIntegralImageOps.getIntegralType(bandType);

		DescribePointSurf<II> alg = FactoryDescribePointAlgs.surfStability( config, integralType);

		if( imageType.getFamily() == ImageType.Family.PLANAR) {
			DescribePointSurfPlanar<II> color = FactoryDescribePointAlgs.surfColor( alg,imageType.getNumBands());

			return new SurfPlanar_to_DescribeRegionPoint(color,bandType,integralType);
		} else {
			throw new IllegalArgumentException("Unknown image type");
		}
	}
373186
public static function getImageLoader(ConfigObject $config)
    {
        $lib = self::getLibrary();

        /** @var ImageLoaderInterface $libInstance */
        $instance = self::factory($lib, ImageLoaderInterface::class, [$config]);

        if (!self::isInstanceOf($instance, ImageLoaderInterface::class)) {
            throw new ImageException('The message library must implement "' . ImageLoaderInterface::class . '".');
        }

        return $instance;
    }
1328852
public static Class<?> getTypeByDescriptor(TypeDescriptor type) {
		if (type == null)
			throw new NullPointerException("Type descriptor cannot be null");

		return getType(type.getName(), type.getLibrary());
	}
575584
public static <T extends ImageGray<T>> T loadImage(String fileName, Class<T> imageType ) {
		BufferedImage img = loadImage(fileName);
		if( img == null )
			return null;

		return ConvertBufferedImage.convertFromSingle(img, (T) null, imageType);
	}
325333
public static <T extends ImageBase<T>> BlurStorageFilter<T> gaussian(ImageType<T> type , double sigma , int radius ) {
		return new BlurStorageFilter<>("gaussian", type, sigma, radius);
	}
829099
public static <T extends ImageGray<T>>
	PointDetector<T> createFast( @Nullable ConfigFastCorner configFast , Class<T> imageType) {
		if( configFast == null )
			configFast = new ConfigFastCorner();
		configFast.checkValidity();

		FastCornerDetector<T> alg = FactoryIntensityPointAlg.fast(configFast.pixelTol, configFast.minContinuous, imageType);
		alg.setMaxFeaturesFraction(configFast.maxFeatures);

		return new WrapFastToPointDetector<>(alg);
	}
883565
@SuppressWarnings("static-method")
	protected ImageDescriptor getImageDescriptor(String imagePath) {
		final LangActivator activator = LangActivator.getInstance();
		final ImageRegistry registry = activator.getImageRegistry();
		ImageDescriptor descriptor = registry.getDescriptor(imagePath);
		if (descriptor == null) {
			descriptor = AbstractUIPlugin.imageDescriptorFromPlugin(activator.getBundle().getSymbolicName(), imagePath);
			if (descriptor != null) {
				registry.put(imagePath, descriptor);
			}
		}
		return descriptor;
	}
152221
public static <I extends ImageGray<I>>
	PointTracker<I> dda_FH_SURF_Stable(
											ConfigFastHessian configDetector ,
											ConfigSurfDescribe.Stability configDescribe ,
											ConfigSlidingIntegral configOrientation ,
											Class<I> imageType)
	{
		ScoreAssociation<TupleDesc_F64> score = FactoryAssociation.scoreEuclidean(TupleDesc_F64.class, true);
		AssociateSurfBasic assoc = new AssociateSurfBasic(FactoryAssociation.greedy(score, 5, true));

		AssociateDescription2D<BrightFeature> generalAssoc =
				new AssociateDescTo2D<>(new WrapAssociateSurfBasic(assoc));

		DetectDescribePoint<I,BrightFeature> fused =
				FactoryDetectDescribe.surfStable(configDetector,configDescribe,configOrientation,imageType);

		DdaManagerDetectDescribePoint<I,BrightFeature> manager = new DdaManagerDetectDescribePoint<>(fused);

		return new DetectDescribeAssociate<>(manager, generalAssoc, new ConfigTrackerDda());
	}
786079
public static <T extends ImageInterleaved<T>> ImageBorder<T> interleavedValue(Class<T> imageType, double value) {
		if( imageType == InterleavedF32.class ) {
			return (ImageBorder<T>) new ImageBorderValue.Value_IL_F32((float) value);
		} else if( imageType == InterleavedF64.class ) {
				return (ImageBorder<T>)new ImageBorderValue.Value_IL_F64(value);
		} else if( InterleavedInteger.class.isAssignableFrom(imageType) ) {
			return (ImageBorder<T>)new ImageBorderValue.Value_IL_S32((int)value);
		} else if( imageType == InterleavedS64.class ) {
			return (ImageBorder<T>)new ImageBorderValue.Value_IL_S64((long)value);
		} else {
			throw new IllegalArgumentException("Unknown image type: "+imageType.getSimpleName());
		}
	}