Creates a SURF feature tracker.
961650
public void createSURF() {
		ConfigFastHessian configDetector = new ConfigFastHessian();
		configDetector.maxFeaturesPerScale = 250;
		configDetector.extractRadius = 3;
		configDetector.initialSampleSize = 2;
		tracker = FactoryPointTracker.dda_FH_SURF_Fast(configDetector, null, null, imageType);
	}
1010479
def get_mouse_pos(self, window_pos=None):
    """"""
    window_pos = window_pos or pygame.mouse.get_pos()
    # +0.5 to center the point on the middle of the pixel.
    window_pt = point.Point(*window_pos) + 0.5
    for surf in reversed(self._surfaces):
      if (surf.surf_type != SurfType.CHROME and
          surf.surf_rect.contains_point(window_pt)):
        surf_rel_pt = window_pt - surf.surf_rect.tl
        world_pt = surf.world_to_surf.back_pt(surf_rel_pt)
        return MousePos(world_pt, surf)
530234
def p_feature_soft(self, t):
        """"""

        t[0] = SoftFeatures(t[2], t[4], line=t.lineno(1))
496155
public static void track(Window window) {
        Preferences prefs = node().node("Windows");

        String bounds = prefs.get(window.getName() + ".bounds", null);
        if (bounds != null) {
            Rectangle rect = (Rectangle) ConverterRegistry.instance().convert(
                    Rectangle.class, bounds);
            window.setBounds(rect);
        }

        window.addComponentListener(WINDOW_DIMENSIONS);
    }
858212
function startTracer() {
  if (!moduleRef) {
    for (var i in window) {
      if ([ 'top', 'document', 'window', 'worker', 'parent', 'frames', 'self', 'performance', 'navigator' ].indexOf(i) === -1) {
        processModules({ exports: window[i], filename: i });
      }
    }
  } else {
    processModules(parentModule);
  }
  active = true;
  measureTracerOverhead();
}
1013801
def circle(surf, xy, r, color=BLACK):
    """"""

    x, y = xy

    x = round(x)
    y = round(y)
    r = round(r)

    gfxdraw.filled_circle(surf, x, y, r, color)
    gfxdraw.aacircle(surf, x, y, r, color)

    r += 1
    return pygame.Rect(x - r, y - r, 2 * r, 2 * r)
14170
def render_obs(self, obs):
    """"""
    start_time = time.time()
    self._obs = obs
    self.check_valid_queued_action()
    self._update_camera(point.Point.build(
        self._obs.observation.raw_data.player.camera))

    for surf in self._surfaces:
      # Render that surface.
      surf.draw(surf)

    mouse_pos = self.get_mouse_pos()
    if mouse_pos:
      # Draw a small mouse cursor
      self.all_surfs(_Surface.draw_circle, colors.green, mouse_pos.world_pos,
                     0.1)

    self.draw_actions()

    with sw("flip"):
      pygame.display.flip()

    self._render_times.append(time.time() - start_time)
520955
function ( tracker, gPoint ) {
            var guid = _generateGuid( tracker, gPoint );

            trackerPoints.push(
                {
                    guid: guid,
                    gPoint: gPoint,
                    lastPos: gPoint.currentPos
                } );

            // Only fire up the interval timer when there's gesture pointers to track
            if ( trackerPoints.length === 1 ) {
                lastTime = $.now();
                intervalId = window.setInterval( _doTracking, 50 );
            }
        }
829434
private void trackWelcomeFiles(final BundleContext bundleContext) {
		final ServiceTracker<WelcomeFileMapping, WelcomeFileWebElement> welcomeFileTracker = WelcomeFileMappingTracker
				.createTracker(extenderContext, bundleContext);

		welcomeFileTracker.open();
		trackers.add(0, welcomeFileTracker);
	}
244639
public KltTrackFault track(KltFeature feature) {

		// precompute bounds and other values
		setAllowedBounds(feature);

		// sanity check to make sure it is actually inside the image
		if ( isFullyOutside(feature.x, feature.y))
			return KltTrackFault.OUT_OF_BOUNDS;

		if (currDesc.data.length < lengthFeature) {
			currDesc.reshape(widthFeature,widthFeature);
		}

		// save the original location so that a drifting fault can be detected
		float origX = feature.x, origY = feature.y;

		// If the feature is complete then the fast code can be used when entirely inside
		boolean complete = isDescriptionComplete(feature);

		float det = 0;

		// make sure its inside this image
		if ( complete ) {
			// see if the determinant is too small
			Gxx = feature.Gxx;
			Gyy = feature.Gyy;
			Gxy = feature.Gxy;
			det = Gxx * Gyy - Gxy * Gxy;
			if (det < config.minDeterminant*lengthFeature) {
				return KltTrackFault.FAILED;
			}
		}

		for (int iter = 0; iter < config.maxIterations; iter++) {
			float dx,dy;
			if( complete && isFullyInside(feature.x, feature.y) ) {
				computeE(feature, feature.x, feature.y);
			} else {
				// once it goes outside it must remain outside.  If it starts outside
				int length = computeGandE_border(feature, feature.x, feature.y);

				det = Gxx * Gyy - Gxy * Gxy;
				if (det <= config.minDeterminant*length) {
					return KltTrackFault.FAILED;
				}
			}

			// solve for D
			dx = (Gyy * Ex - Gxy * Ey) / det;
			dy = (Gxx * Ey - Gxy * Ex) / det;

			feature.x += dx;
			feature.y += dy;

			// see if it moved outside of the image
			if ( isFullyOutside(feature.x, feature.y))
				return KltTrackFault.OUT_OF_BOUNDS;

			// see if it has moved more than possible if it is really tracking a target
			// this happens in regions with little texture
			if (Math.abs(feature.x - origX) > widthFeature
					|| Math.abs(feature.y - origY) > widthFeature)
				return KltTrackFault.DRIFTED;

			// see if it has converged to a solution
			if (Math.abs(dx) < config.minPositionDelta && Math.abs(dy) < config.minPositionDelta) {
				break;
			}
		}

		if ( (error=computeError(feature)) > config.maxPerPixelError)
			return KltTrackFault.LARGE_ERROR;

		return KltTrackFault.SUCCESS;
	}
611903
def render(self, surf):
        """"""

        if self.clicked:
            icon = self.icon_pressed
        else:
            icon = self.icon

        surf.blit(icon, self)
1334813
public static void easy( GrayF32 image ) {
		// create the detector and descriptors
		DetectDescribePoint<GrayF32,BrightFeature> surf = FactoryDetectDescribe.
				surfStable(new ConfigFastHessian(0, 2, 200, 2, 9, 4, 4), null, null,GrayF32.class);

		 // specify the image to process
		surf.detect(image);

		System.out.println("Found Features: "+surf.getNumberOfFeatures());
		System.out.println("First descriptor's first value: "+surf.getDescription(0).value[0]);
	}
522162
private void trackResources(final BundleContext bundleContext) {
		ServiceTracker<Object, ResourceWebElement> resourceTracker = ResourceTracker.createTracker(extenderContext, bundleContext);

		resourceTracker.open();
		trackers.add(0, resourceTracker);

		final ServiceTracker<ResourceMapping, ResourceMappingWebElement> resourceMappingTracker = ResourceMappingTracker
				.createTracker(extenderContext, bundleContext);

		resourceMappingTracker.open();
		trackers.add(0, resourceMappingTracker);
	}
669979
def draw_screen(self, surf):
    """"""
    # surf.fill(colors.black)
    if (self._render_rgb and self._obs.observation.HasField("render_data") and
        self._obs.observation.render_data.HasField("map")):
      self.draw_rendered_map(surf)
    else:
      self.draw_base_map(surf)
      self.draw_units(surf)
    self.draw_selection(surf)
    self.draw_build_target(surf)
    self.draw_overlay(surf)
    self.draw_commands(surf)
    self.draw_panel(surf)
523574
def _generateFeatures(self):
    
    size = self.sensorInputSize
    bits = self.numInputBits

    self.features = []
    for _ in xrange(self.numColumns):
      self.features.append(
        [self._generatePattern(bits, size) for _ in xrange(self.numFeatures)]
    )
18270
def add_container_to_pose_tracker(self, location, container: Container):
        
        self.poses = pose_tracker.add(
            self.poses,
            container,
            container.parent,
            pose_tracker.Point(*container._coordinates))

        for well in container:
            center_x, center_y, center_z = well.top()[1]
            offset_x, offset_y, offset_z = well._coordinates
            center_z = 0
            self.poses = pose_tracker.add(
                self.poses,
                well,
                container,
                pose_tracker.Point(
                    center_x + offset_x,
                    center_y + offset_y,
                    center_z + offset_z
                )
            )
1187254
private void trackServlets(final BundleContext bundleContext) {
		final ServiceTracker<Servlet, ServletWebElement> servletTracker = ServletTracker
				.createTracker(extenderContext, bundleContext);

		servletTracker.open();
		trackers.add(0, servletTracker);

		final ServiceTracker<ServletMapping, ServletMappingWebElement> servletMappingTracker = ServletMappingTracker
				.createTracker(extenderContext, bundleContext);

		servletMappingTracker.open();
		trackers.add(0, servletMappingTracker);
	}