// 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;
}
}
