// Deinitializes the tracker of the given type and frees any resources // used by the tracker. // Deinitializing a tracker must not be done when the CameraDevice // is initialized or started. This function will return false if the // tracker of the given type has not been initialized or if the // CameraDevice is currently initialized. public override bool DeinitTracker(Tracker.Type trackerType) { if (QCARWrapper.Instance.TrackerManagerDeinitTracker((int)trackerType) == 0) { Debug.LogError("Could not deinitialize the tracker."); return(false); } if (trackerType == Tracker.Type.IMAGE_TRACKER) { mImageTracker = null; } else if (trackerType == Tracker.Type.MARKER_TRACKER) { mMarkerTracker = null; } else if (trackerType == Tracker.Type.TEXT_TRACKER) { mTextTracker = null; } else { Debug.LogError("Could not deinitialize tracker. Unknown tracker type."); return(false); } return(true); }
// Deinitializes the tracker of the given type and frees any resources // used by the tracker. // Deinitializing a tracker must not be done when the CameraDevice // is initialized or started. This function will return false if the // tracker of the given type has not been initialized or if the // CameraDevice is currently initialized. public override bool DeinitTracker(Tracker.Type trackerType) { if (QCARWrapper.Instance.TrackerManagerDeinitTracker((int)trackerType) == 0) { Debug.LogError("Could not deinitialize the tracker."); return false; } if (trackerType == Tracker.Type.IMAGE_TRACKER) { mImageTracker = null; } else if (trackerType == Tracker.Type.MARKER_TRACKER) { mMarkerTracker = null; } else if (trackerType == Tracker.Type.TEXT_TRACKER) { mTextTracker = null; } else { Debug.LogError("Could not deinitialize tracker. Unknown tracker type."); return false; } return true; }
private void UseArMarkers() { var pos = MarkerTracker.GetPosition(); var rot = MarkerTracker.GetRotation(); switch (CurrentMode) { case TrackingMode.Optitrack: CurrentMode = TrackingMode.TransitionToArMarker; StartAnimations(pos, rot); ApplyTransform(_positionAnimation.CurrentValue, _rotationAnimation.CurrentValue); break; case TrackingMode.ArMarker: ApplyTransform(pos, rot); break; case TrackingMode.TransitionToArMarker: AdjustAnimations(pos, rot); ApplyTransform(_positionAnimation.CurrentValue, _rotationAnimation.CurrentValue); break; case TrackingMode.TransitionToOptitrack: CurrentMode = TrackingMode.TransitionToArMarker; RestartAnimations(pos, rot); ApplyTransform(_positionAnimation.CurrentValue, _rotationAnimation.CurrentValue); break; } }
// Initializes the tracker of the given type // Initializing a tracker must not be done when the CameraDevice // is initialized or started. This function will return null if the // CameraDevice is currently initialized. public Tracker InitTracker(Tracker.Type trackerType) { if (Application.isEditor) { return(null); } if (trackerManagerInitTracker((int)trackerType) == 0) { Debug.LogError("Could not initialize the tracker."); return(null); } if (trackerType == Tracker.Type.IMAGE_TRACKER) { if (mImageTracker == null) { mImageTracker = new ImageTracker(); } return(mImageTracker); } else if (trackerType == Tracker.Type.MARKER_TRACKER) { if (mMarkerTracker == null) { mMarkerTracker = new MarkerTracker(); } return(mMarkerTracker); } else { Debug.LogError("Could not initialize tracker. Unknown tracker type."); return(null); } }
// Deinitialize QCAR and trackers when QCARBehaviour is destroyed. void OnDestroy() { // Destroy all the datasets ImageTracker imageTracker = (ImageTracker)TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER); if (imageTracker != null) { imageTracker.DestroyAllDataSets(false); } // Destroy all the markers MarkerTracker markerTracker = (MarkerTracker)TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER); if (markerTracker != null) { markerTracker.DestroyAllMarkers(false); } // Deinit the QCARManager QCARManager.Instance.Deinit(); // Deinit the trackers if (TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER) != null) { TrackerManager.Instance.DeinitTracker(Tracker.Type.MARKER_TRACKER); } if (TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER) != null) { TrackerManager.Instance.DeinitTracker(Tracker.Type.IMAGE_TRACKER); } }
public override void Load(IServiceProvider provider) { var workflow = (ExpressionBuilderGraph)provider.GetService(typeof(ExpressionBuilderGraph)); var context = (ITypeVisualizerContext)provider.GetService(typeof(ITypeVisualizerContext)); if (context != null) { var workflowNode = (from node in workflow where node.Value == context.Source select node).FirstOrDefault(); var trackerNode = workflow.Predecessors(workflowNode).Single(); var trackerBuilder = trackerNode.Value as SelectBuilder; if (trackerBuilder != null) { tracker = (MarkerTracker)trackerBuilder.Projection; } var inputNode = workflow.Predecessors(trackerNode).Select(node => node.Value as InspectBuilder).SingleOrDefault(); if (inputNode != null) { inputObserver = inputNode.Output.Subscribe(output => input = output as IplImage); } } base.Load(provider); }
/// <summary> /// Initializes the tracking, Activates the trackers, susbcribes to the <see cref="ArucoObjectsController{T}.ArucoObjectAdded"/> and /// <see cref="ArucoObjectsController{T}.ArucoObjectRemoved"/> events and starts the tracking thread. /// </summary> public override void StartController() { base.StartController(); // Initialize the tracking trackingImages = new Cv.Mat[ArucoCamera.CameraNumber]; trackingImagesData = new byte[ArucoCamera.CameraNumber][]; arucoCameraImageCopyData = new byte[ArucoCamera.CameraNumber][]; for (int cameraId = 0; cameraId < ArucoCamera.CameraNumber; cameraId++) { arucoCameraImageCopyData[cameraId] = new byte[ArucoCamera.ImageDataSizes[cameraId]]; trackingImagesData[cameraId] = new byte[ArucoCamera.ImageDataSizes[cameraId]]; Texture2D imageTexture = ArucoCamera.ImageTextures[cameraId]; trackingImages[cameraId] = new Cv.Mat(imageTexture.height, imageTexture.width, CvMatExtensions.ImageType(imageTexture.format)); trackingImages[cameraId].DataByte = trackingImagesData[cameraId]; } // Activate the trackers MarkerTracker.Activate(this); foreach (var arucoObjectDictionary in ArucoObjects) { foreach (var arucoObject in arucoObjectDictionary.Value) { ArucoObjectsController_ArucoObjectAdded(arucoObject.Value); } } // Subscribes to ArucoObjectsController and ArucoCamera events ArucoObjectAdded += ArucoObjectsController_ArucoObjectAdded; ArucoObjectRemoved += ArucoObjectsController_ArucoObjectRemoved; arucoCameraImagesUpdated = false; ArucoCamera.ImagesUpdated += ArucoCamera_ImagesUpdated; // Start the tracking thread trackingThread = new Thread(() => { try { while (IsConfigured && IsStarted) { trackingMutex.WaitOne(); Track(); trackingMutex.ReleaseMutex(); } } catch (Exception e) { trackingException = e; trackingMutex.ReleaseMutex(); } }); trackingThread.Start(); OnStarted(); }
// Deinitialize QCAR and trackers when QCARBehaviour is destroyed. void OnDestroy() { // clear all trackable results in the StateManager StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager(); stateManager.ClearTrackableBehaviours(); // Destroy all the datasets ImageTracker imageTracker = (ImageTracker)TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER); if (imageTracker != null) { imageTracker.DestroyAllDataSets(false); imageTracker.Stop(); } // Destroy all the markers MarkerTracker markerTracker = (MarkerTracker)TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER); if (markerTracker != null) { markerTracker.DestroyAllMarkers(false); markerTracker.Stop(); } TextTracker textTracker = (TextTracker)TrackerManager.Instance.GetTracker(Tracker.Type.TEXT_TRACKER); if (textTracker != null) { textTracker.Stop(); } // Deinit the QCARManager QCARManager.Instance.Deinit(); // Deinit the trackers if (TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER) != null) { TrackerManager.Instance.DeinitTracker(Tracker.Type.MARKER_TRACKER); } if (TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER) != null) { TrackerManager.Instance.DeinitTracker(Tracker.Type.IMAGE_TRACKER); } if (TrackerManager.Instance.GetTracker(Tracker.Type.TEXT_TRACKER) != null) { TrackerManager.Instance.DeinitTracker(Tracker.Type.TEXT_TRACKER); } if (QCARRuntimeUtilities.IsPlayMode()) { // deinit explicitly if running in the emulator QCARWrapper.Instance.QcarDeinit(); } }
public void StopTracking() { Vuforia.enabled = false; ObjectTracker it = TrackerManager.Instance.GetTracker <ObjectTracker>(); MarkerTracker mt = TrackerManager.Instance.GetTracker <MarkerTracker>(); it.Stop(); mt.Stop(); CameraDevice.Instance.Stop(); }
private void OnDestroy() { ((StateManagerImpl)TrackerManager.Instance.GetStateManager()).ClearTrackableBehaviours(); ImageTracker tracker = TrackerManager.Instance.GetTracker <ImageTracker>(); if (tracker != null) { tracker.DestroyAllDataSets(false); tracker.Stop(); } MarkerTracker tracker2 = TrackerManager.Instance.GetTracker <MarkerTracker>(); if (tracker2 != null) { tracker2.DestroyAllMarkers(false); tracker2.Stop(); } TextTracker tracker3 = TrackerManager.Instance.GetTracker <TextTracker>(); if (tracker3 != null) { tracker3.Stop(); } QCARManager.Instance.Deinit(); if (tracker2 != null) { TrackerManager.Instance.DeinitTracker <MarkerTracker>(); } if (tracker != null) { TrackerManager.Instance.DeinitTracker <ImageTracker>(); } if (tracker3 != null) { TrackerManager.Instance.DeinitTracker <TextTracker>(); } if (QCARRuntimeUtilities.IsPlayMode()) { QCARWrapper.Instance.QcarDeinit(); } if (this.mAndroidUnityPlayer != null) { this.mAndroidUnityPlayer.Dispose(); } }
/// <summary> /// Unsuscribes from ArucoObjectController events, deactivates the trackers and abort the tracking thread and stops the tracking thread. /// </summary> public override void StopController() { base.StopController(); ArucoObjectAdded -= ArucoObjectsController_ArucoObjectAdded; ArucoObjectRemoved -= ArucoObjectsController_ArucoObjectRemoved; MarkerTracker.Deactivate(); foreach (var tracker in additionalTrackers) { if (tracker.Value.IsActivated) { tracker.Value.Deactivate(); } } OnStopped(); }
// Initialize the container for retrieving tracking data from native private void InitializeTrackableContainer() { // Destroy if the container has been allocated. Marshal.FreeHGlobal(mTrackablePtr); mAbsoluteNumTrackables = 0; ImageTracker imageTracker = (ImageTracker)TrackerManager.Instance.GetTracker( Tracker.Type.IMAGE_TRACKER); MarkerTracker markerTracker = (MarkerTracker)TrackerManager.Instance.GetTracker( Tracker.Type.MARKER_TRACKER); if (imageTracker != null) { DataSet activeDataSet = imageTracker.GetActiveDataSet(); if (activeDataSet != null) { mAbsoluteNumTrackables += activeDataSet.GetNumTrackables(); } } if (markerTracker != null) { mAbsoluteNumTrackables += markerTracker.GetNumMarkers(); } if (mAbsoluteNumTrackables > 0) { mTrackablePtr = Marshal.AllocHGlobal(Marshal.SizeOf( typeof(TrackableData)) * mAbsoluteNumTrackables); } else { mTrackablePtr = IntPtr.Zero; } mTrackableDataArray = new TrackableData[mAbsoluteNumTrackables]; if (!Application.isEditor) { Debug.Log("Absolute number of Trackables: " + mAbsoluteNumTrackables); } }
// Initializes the tracker of the given type // Initializing a tracker must not be done when the CameraDevice // is initialized or started. This function will return null if the // CameraDevice is currently initialized. public override Tracker InitTracker(Tracker.Type trackerType) { if (!QCARRuntimeUtilities.IsQCAREnabled()) { return(null); } if (QCARWrapper.Instance.TrackerManagerInitTracker((int)trackerType) == 0) { Debug.LogError("Could not initialize the tracker."); return(null); } if (trackerType == Tracker.Type.IMAGE_TRACKER) { if (mImageTracker == null) { mImageTracker = new ImageTrackerImpl(); } return(mImageTracker); } else if (trackerType == Tracker.Type.MARKER_TRACKER) { if (mMarkerTracker == null) { mMarkerTracker = new MarkerTrackerImpl(); } return(mMarkerTracker); } else if (trackerType == Tracker.Type.TEXT_TRACKER) { if (mTextTracker == null) { mTextTracker = new TextTrackerImpl(); } return(mTextTracker); } else { Debug.LogError("Could not initialize tracker. Unknown tracker type."); return(null); } }
private void FixedUpdate() { MarkerTracker.PreparePose(); VrTracker.PreparePose(); OptitrackTracker.PreparePose(); #if UNITY_EDITOR _positionAnimation.AnimationSpeed = SwitchTransitionSpeed; _rotationAnimation.AnimationSpeed = SwitchTransitionSpeed; #endif if (MarkerTracker.HasPose()) { UseArMarkers(); } else { UseOptitrack(); } }
private void StartQCAR() { Debug.Log("StartQCAR"); CameraDevice.Instance.Init(this.CameraDirection); CameraDevice.Instance.SelectVideoMode(this.CameraDeviceModeSetting); CameraDevice.Instance.Start(); MarkerTracker tracker = TrackerManager.Instance.GetTracker <MarkerTracker>(); if (tracker != null) { tracker.Start(); } ImageTracker tracker2 = TrackerManager.Instance.GetTracker <ImageTracker>(); if (tracker2 != null) { tracker2.Start(); } ScreenOrientation surfaceOrientation = (ScreenOrientation)QCARWrapper.Instance.GetSurfaceOrientation(); this.UpdateProjection(surfaceOrientation); }
/// <summary> /// Initializes the tracking, activates the trackers, susbcribes to the <see cref="ArucoObjectsController{T}.ArucoObjectAdded"/> and /// <see cref="ArucoObjectsController{T}.ArucoObjectRemoved"/> events and starts the tracking thread. /// </summary> public override void StartController() { base.StartController(); MarkerTracker.Activate(this); foreach (var arucoObjectDictionary in ArucoObjects) { foreach (var arucoObject in arucoObjectDictionary.Value) { ArucoObjectsController_ArucoObjectAdded(arucoObject.Value); } } ArucoObjectAdded += ArucoObjectsController_ArucoObjectAdded; ArucoObjectRemoved += ArucoObjectsController_ArucoObjectRemoved; trackingThread = new ArucoCameraSeparateThread(ArucoCamera, UpdateArucoObjects, TrackArucoObjects, () => { StopController(); }); trackingThread.Start(); OnStarted(); }
public override T InitTracker <T>() /*where T: Tracker*/ { if (QCARRuntimeUtilities.IsQCAREnabled()) { if (QCARWrapper.Instance.TrackerManagerInitTracker(TypeMapping.GetTypeID(typeof(T))) == 0) { Debug.LogError("Could not initialize the tracker."); return(default(T)); } if (typeof(T) == typeof(ImageTracker)) { if (this.mImageTracker == null) { this.mImageTracker = new ImageTrackerImpl(); } return(this.mImageTracker as T); } if (typeof(T) == typeof(MarkerTracker)) { if (this.mMarkerTracker == null) { this.mMarkerTracker = new MarkerTrackerImpl(); } return(this.mMarkerTracker as T); } if (typeof(T) == typeof(TextTracker)) { if (this.mTextTracker == null) { this.mTextTracker = new TextTrackerImpl(); } return(this.mTextTracker as T); } Debug.LogError("Could not initialize tracker. Unknown tracker type."); } return(default(T)); }
// Initializes the tracker of the given type // Initializing a tracker must not be done when the CameraDevice // is initialized or started. This function will return null if the // CameraDevice is currently initialized. public override Tracker InitTracker(Tracker.Type trackerType) { if (!QCARRuntimeUtilities.IsQCAREnabled()) { return null; } if (QCARWrapper.Instance.TrackerManagerInitTracker((int)trackerType) == 0) { Debug.LogError("Could not initialize the tracker."); return null; } if (trackerType == Tracker.Type.IMAGE_TRACKER) { if (mImageTracker == null) { mImageTracker = new ImageTrackerImpl(); } return mImageTracker; } else if (trackerType == Tracker.Type.MARKER_TRACKER) { if (mMarkerTracker == null) { mMarkerTracker = new MarkerTrackerImpl(); } return mMarkerTracker; } else { Debug.LogError("Could not initialize tracker. Unknown tracker type."); return null; } }
// Starts up the QCAR extension with the properties that were set in the // Unity inspector. void Start() { // First we check if QCAR initialized correctly. if (QCAR.CheckInitializationError() != QCAR.InitError.INIT_SUCCESS) { mIsInitialized = false; return; } // Initialize the trackers if they haven't already been initialized. if (TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER) == null) { TrackerManager.Instance.InitTracker(Tracker.Type.MARKER_TRACKER); } if (TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER) == null) { TrackerManager.Instance.InitTracker(Tracker.Type.IMAGE_TRACKER); } // Cache the camera start values mCachedDrawVideoBackground = QCARManager.Instance.DrawVideoBackground; mCachedCameraClearFlags = this.camera.clearFlags; mCachedCameraBackgroundColor = this.camera.backgroundColor; // Reset the camera clear flags and create a simple material ResetCameraClearFlags(); mClearMaterial = new Material(Shader.Find("Diffuse")); // Set QCAR hints from the Inspector options QCAR.SetHint(QCAR.QCARHint.HINT_MAX_SIMULTANEOUS_IMAGE_TARGETS, MaxSimultaneousImageTargets); QCAR.SetHint(QCAR.QCARHint.HINT_IMAGE_TARGET_MULTI_FRAME_ENABLED, MultiFrameEnabled ? 1 : 0); // Set the Unity version for internal use QCAR.SetUnityVersion(); // Find markers in the scene and register them with QCAR MarkerBehaviour[] markerBehaviours = (MarkerBehaviour[]) UnityEngine.Object.FindObjectsOfType(typeof(MarkerBehaviour)); MarkerTracker markerTracker = (MarkerTracker)TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER); if (markerTracker != null) { markerTracker.AddMarkers(markerBehaviours); } // Start the camera and tracker StartQCAR(); // Initialize the QCARManager QCARManager.Instance.WorldCenterMode = mWorldCenterMode; QCARManager.Instance.WorldCenter = mWorldCenter; QCARManager.Instance.ARCamera = camera; QCARManager.Instance.Init(); // Initialize local variables mIsInitialized = true; mHasStartedOnce = true; }
// Unmarshal and process the tracking data private void UpdateTrackers() { if (Application.isEditor) { UpdateTrackablesEditor(); return; } // Unmarshal the trackable data // Take our array of unmanaged data from native and create an array of // TrackableData structures to work with (one per trackable, regardless // of whether or not that trackable is visible this frame). for (int i = 0; i < mAbsoluteNumTrackables; i++) { IntPtr trackablePtr = new IntPtr(mTrackablePtr.ToInt32() + i * Marshal.SizeOf(typeof(TrackableData))); TrackableData trackableData = (TrackableData) Marshal.PtrToStructure(trackablePtr, typeof(TrackableData)); mTrackableDataArray[i] = trackableData; } // Add newly found Trackables to the queue, remove lost ones // We keep track of the order in which Trackables become visible for the // AUTO World Center mode. This keeps the camera from jumping around in the // scene too much. foreach (TrackableData trackableData in mTrackableDataArray) { // We found a trackable (or set of Trackables) that match this id if ((trackableData.status == TrackableBehaviour.Status.DETECTED || trackableData.status == TrackableBehaviour.Status.TRACKED)) { if (!mTrackableFoundQueue.Contains(trackableData.id)) { // The trackable just became visible, add it to the queue mTrackableFoundQueue.AddLast(trackableData.id); } } else { if (mTrackableFoundQueue.Contains(trackableData.id)) { // The trackable just disappeared, remove it from the queue mTrackableFoundQueue.Remove(trackableData.id); } } } ImageTracker imageTracker = (ImageTracker) TrackerManager.Instance.GetTracker(Tracker.Type.IMAGE_TRACKER); MarkerTracker markerTracker = (MarkerTracker) TrackerManager.Instance.GetTracker(Tracker.Type.MARKER_TRACKER); // The "scene origin" is only used in world center mode auto or user. int originTrackableID = -1; if (mWorldCenterMode == QCARBehaviour.WorldCenterMode.USER && mWorldCenter != null) { originTrackableID = mWorldCenter.TrackableID; } else if (mWorldCenterMode == QCARBehaviour.WorldCenterMode.AUTO) { imageTracker.RemoveDisabledTrackablesFromQueue(ref mTrackableFoundQueue); markerTracker.RemoveDisabledTrackablesFromQueue(ref mTrackableFoundQueue); if (mTrackableFoundQueue.Count > 0) { originTrackableID = mTrackableFoundQueue.First.Value; } } // Update the Camera pose before Trackable poses are updated. imageTracker.UpdateCameraPose(mARCamera, mTrackableDataArray, originTrackableID); markerTracker.UpdateCameraPose(mARCamera, mTrackableDataArray, originTrackableID); // Update the Trackable poses. imageTracker.UpdateTrackablePoses(mARCamera, mTrackableDataArray, originTrackableID); markerTracker.UpdateTrackablePoses(mARCamera, mTrackableDataArray, originTrackableID); imageTracker.UpdateVirtualButtons(mAbsoluteNumVirtualButtons, mVirtualButtonPtr); }
// Initializes the tracker of the given type // Initializing a tracker must not be done when the CameraDevice // is initialized or started. This function will return null if the // CameraDevice is currently initialized. public Tracker InitTracker(Tracker.Type trackerType) { if (Application.isEditor) { return null; } if (trackerManagerInitTracker((int)trackerType) == 0) { Debug.LogError("Could not initialize the tracker."); return null; } if (trackerType == Tracker.Type.IMAGE_TRACKER) { if (mImageTracker == null) { mImageTracker = new ImageTracker(); } return mImageTracker; } else if (trackerType == Tracker.Type.MARKER_TRACKER) { if (mMarkerTracker == null) { mMarkerTracker = new MarkerTracker(); } return mMarkerTracker; } else { Debug.LogError("Could not initialize tracker. Unknown tracker type."); return null; } }