Detects Kitchen and Rosenfeld corners.

@param configDetector Configuration for feature detector.
@param derivType       Type of derivative image.
@see boofcv.alg.feature.detect.intensity.KitRosCornerIntensity
320138
public static <T extends ImageGray<T>, D extends ImageGray<D>>
	GeneralFeatureDetector<T, D> createKitRos(@Nullable ConfigGeneralDetector configDetector, Class<D> derivType) {
		if( configDetector == null)
			configDetector = new ConfigGeneralDetector();

		GeneralFeatureIntensity<T, D> intensity = new WrapperKitRosCornerIntensity<>(derivType);
		return createGeneral(intensity, configDetector);
	}
655933
public static TriangulateNViewsMetric triangulateNViewCalibrated(@Nullable ConfigTriangulation config ) {
		if( config == null )
			config = new ConfigTriangulation();

		switch ( config.type ) {
			case DLT:
				return new WrapNViewsTriangulateMetricDLT();

			case GEOMETRIC: {
				TriangulateNViewsMetric estimator = new WrapNViewsTriangulateMetricDLT();
				TriangulateRefineMetricLS refiner = new TriangulateRefineMetricLS(config.optimization.gtol,config.optimization.maxIterations);
				return new TriangulateThenRefineMetric(estimator,refiner);
			}

		}
		throw new IllegalArgumentException("Unknown or unsupported type "+config.type);
	}
609234
void computeRawDescriptor(double c_x, double c_y, double sigma, double orientation, TupleDesc_F64 descriptor) {
		double c = Math.cos(orientation);
		double s = Math.sin(orientation);

		float fwidthSubregion = widthSubregion;
		int sampleWidth = widthGrid*widthSubregion;
		double sampleRadius = sampleWidth/2;

		double sampleToPixels = sigma*sigmaToPixels;

		Deriv image = (Deriv)imageDerivX.getImage();

		for (int sampleY = 0; sampleY < sampleWidth; sampleY++) {
			float subY = sampleY/fwidthSubregion;
			double y = sampleToPixels*(sampleY-sampleRadius);

			for (int sampleX = 0; sampleX < sampleWidth; sampleX++) {
				// coordinate of samples in terms of sub-region.  Center of sample point, hence + 0.5f
				float subX = sampleX/fwidthSubregion;
				// recentered local pixel sample coordinate
				double x = sampleToPixels*(sampleX-sampleRadius);

				// pixel coordinate in the image that is to be sampled.  Note the rounding
				// If the pixel coordinate is -1 < x < 0 then it will round to 0 instead of -1, but the rounding
				// method below is WAY faster than Math.round() so this is a small loss.
				int pixelX = (int)(x*c - y*s + c_x + 0.5);
				int pixelY = (int)(x*s + y*c + c_y + 0.5);

				// skip pixels outside of the image
				if( image.isInBounds(pixelX,pixelY) ) {
					// spacial image derivative at this point
					float spacialDX = imageDerivX.unsafe_getF(pixelX, pixelY);
					float spacialDY = imageDerivY.unsafe_getF(pixelX, pixelY);

					double adjDX =  c*spacialDX + s*spacialDY;
					double adjDY = -s*spacialDX + c*spacialDY;

					double angle = UtilAngle.domain2PI(Math.atan2(adjDY,adjDX));

					float weightGaussian = gaussianWeight[sampleY*sampleWidth+sampleX];
					float weightGradient = (float)Math.sqrt(spacialDX*spacialDX + spacialDY*spacialDY);

					// trilinear interpolation intro descriptor
					trilinearInterpolation(weightGaussian*weightGradient,subX,subY,angle, descriptor);
				}
			}
		}
	}
376746
static public void direction(GrayF32 derivX , GrayF32 derivY , GrayF32 angle )
	{
		InputSanityCheck.checkSameShape(derivX,derivY);
		angle.reshape(derivX.width,derivX.height);

		if(BoofConcurrency.USE_CONCURRENT ) {
			ImplGradientToEdgeFeatures_MT.direction(derivX,derivY,angle);
		} else {
			ImplGradientToEdgeFeatures.direction(derivX,derivY,angle);
		}
	}
992759
function(geometry, style, featureId) {
        var img = new Image();

        var title = style.title || style.graphicTitle;        
        if (title) {
            img.title = title;           
        }

        var width = style.graphicWidth || style.graphicHeight;
        var height = style.graphicHeight || style.graphicWidth;
        width = width ? width : style.pointRadius * 2;
        height = height ? height : style.pointRadius * 2;
        var xOffset = (style.graphicXOffset != undefined) ?
           style.graphicXOffset : -(0.5 * width);
        var yOffset = (style.graphicYOffset != undefined) ?
           style.graphicYOffset : -(0.5 * height);

        var opacity = style.graphicOpacity || style.fillOpacity;
        
        var onLoad = function() {
            if(!this.features[featureId]) {
                return;
            }
            var pt = this.getLocalXY(geometry);
            var p0 = pt[0];
            var p1 = pt[1];
            if(!isNaN(p0) && !isNaN(p1)) {
                var x = (p0 + xOffset) | 0;
                var y = (p1 + yOffset) | 0;
                var canvas = this.canvas;
                canvas.globalAlpha = opacity;
                var factor = OpenLayers.Renderer.Canvas.drawImageScaleFactor ||
                    (OpenLayers.Renderer.Canvas.drawImageScaleFactor =
                        /android 2.1/.test(navigator.userAgent.toLowerCase()) ?
                            // 320 is the screen width of the G1 phone, for
                            // which drawImage works out of the box.
                            320 / window.screen.width : 1
                    );
                canvas.drawImage(
                    img, x*factor, y*factor, width*factor, height*factor
                );
                if (this.hitDetection) {
                    this.setHitContextStyle("fill", featureId);
                    this.hitContext.fillRect(x, y, width, height);
                }
            }
        };

        img.onload = OpenLayers.Function.bind(onLoad, this);
        img.src = style.externalGraphic;
    }
1328849
public static <T extends ImageGray<T>, D extends ImageGray<D>>
	GeneralFeatureDetector<T, D> createMedian(@Nullable ConfigGeneralDetector configDetector, Class<T> imageType) {

		if( configDetector == null)
			configDetector = new ConfigGeneralDetector();

		BlurStorageFilter<T> medianFilter = FactoryBlurFilter.median(ImageType.single(imageType), configDetector.radius);
		GeneralFeatureIntensity<T, D> intensity = new WrapperMedianCornerIntensity<>(medianFilter);
		return createGeneral(intensity, configDetector);
	}
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);
	}
358114
public static CalibrationDetectorCircleRegularGrid circleRegularGrid( @Nullable ConfigCircleRegularGrid config ,
																		  ConfigGridDimen configGrid ) {
		if( config == null )
			config = new ConfigCircleRegularGrid();
		config.checkValidity();

		return new CalibrationDetectorCircleRegularGrid(config,configGrid);
	}
96761
public static <I extends ImageGray<I>, D extends ImageGray<D>>
	GeneralFeatureIntensity<I,D> hessian(HessianBlobIntensity.Type type, Class<D> derivType) {
		return new WrapperHessianBlobIntensity<>(type, derivType);
	}
556946
def detector(detector_type):
        
        if detector_type == 'point_cloud_box':
            return PointCloudBoxDetector()
        elif detector_type == 'rgbd_foreground_mask_query':
            return RgbdForegroundMaskQueryImageDetector()
        elif detector_type == 'rgbd_foreground_mask':
            return RgbdForegroundMaskDetector()
        raise ValueError('Detector type %s not understood' %(detector_type))
1093679
@Deprecated
	public static CalibrationDetectorChessboard chessboard(@Nullable ConfigChessboard configDet ,
														   ConfigGridDimen configGrid ) {
		if( configDet == null )
			configDet = new ConfigChessboard();
		configDet.checkValidity();

		return new CalibrationDetectorChessboard(configDet,configGrid);
	}
378543
public static <D extends ImageGray<D>>
	OrientationHistogramSift<D> sift(ConfigSiftOrientation config , Class<D> derivType ) {
		if( config == null )
			config = new ConfigSiftOrientation();
		config.checkValidity();

		return new OrientationHistogramSift(config.histogramSize,config.sigmaEnlarge,derivType);
	}
562921
@Override
	protected T doSwitch(int classifierID, EObject theEObject) {
		switch (classifierID) {
		case GeometryPackage.GEOMETRY_INFO: {
			GeometryInfo geometryInfo = (GeometryInfo) theEObject;
			T result = caseGeometryInfo(geometryInfo);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.VECTOR3F: {
			Vector3f vector3f = (Vector3f) theEObject;
			T result = caseVector3f(vector3f);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.BOUNDS: {
			Bounds bounds = (Bounds) theEObject;
			T result = caseBounds(bounds);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.BUFFER: {
			Buffer buffer = (Buffer) theEObject;
			T result = caseBuffer(buffer);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.GEOMETRY_DATA: {
			GeometryData geometryData = (GeometryData) theEObject;
			T result = caseGeometryData(geometryData);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.VECTOR4F: {
			Vector4f vector4f = (Vector4f) theEObject;
			T result = caseVector4f(vector4f);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		case GeometryPackage.COLOR_PACK: {
			ColorPack colorPack = (ColorPack) theEObject;
			T result = caseColorPack(colorPack);
			if (result == null)
				result = defaultCase(theEObject);
			return result;
		}
		default:
			return defaultCase(theEObject);
		}
	}
663005
final boolean detectInheritanceCycle() {
    if (detectImplicitPrototypeCycle()
        || Iterables.contains(this.getCtorImplementedInterfaces(), this)) {
        return true;
    }
    FunctionType fnType = this.getConstructor();
    return fnType != null && fnType.checkExtendsLoop() != null;
  }
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());
	}
903617
public static boolean isTypeManagedBeanOrDecoratorOrInterceptor(AnnotatedType<?> annotatedType) {
        Class<?> javaClass = annotatedType.getJavaClass();
        return !javaClass.isEnum() && !Extension.class.isAssignableFrom(javaClass)
                && Reflections.isTopLevelOrStaticNestedClass(javaClass) && !Reflections.isParameterizedTypeWithWildcard(javaClass)
                && hasSimpleCdiConstructor(annotatedType);
    }
959937
public void setImage(I image, D derivX, D derivY) {
		InputSanityCheck.checkSameShape(image, derivX, derivY);

		this.image = image;
		this.interpInput.setImage(image);

		this.derivX = derivX;
		this.derivY = derivY;
	}