// 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;
}
void Update()
{
if (mIsInitialized)
{
// Once the text tracker has initialized and every time the video background changed,
// set the region of interest
if (mVideoBackgroundChanged)
{
TextTracker textTracker = TrackerManager.Instance.GetTracker <TextTracker>();
if (textTracker != null)
{
CalculateLoupeRegion();
textTracker.SetRegionOfInterest(mDetectionAndTrackingRect, mDetectionAndTrackingRect);
}
mVideoBackgroundChanged = false;
}
}
//if found
if (status && myWord != null)
{
StartCoroutine("lookUp");
setActive(true);
}
else
{
StopCoroutine("lookUp");
setActive(false);
}
}
public override bool DeinitTracker <T>() /*where T: Tracker*/
{
if (QCARWrapper.Instance.TrackerManagerDeinitTracker(TypeMapping.GetTypeID(typeof(T))) == 0)
{
Debug.LogError("Could not deinitialize the tracker.");
return(false);
}
if (typeof(T) == typeof(ImageTracker))
{
this.mImageTracker = null;
}
else if (typeof(T) == typeof(MarkerTracker))
{
this.mMarkerTracker = null;
}
else if (typeof(T) == typeof(TextTracker))
{
this.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);
}
void Update()
{
if (mIsInitialized)
{
// Once the text tracker has initialized and every time the video background changed,
// set the region of interest
if (mVideoBackgroundChanged)
{
TextTracker textTracker = TrackerManager.Instance.GetTracker <TextTracker> ();
if (textTracker != null)
{
CalculateLoupeRegion();
textTracker.SetRegionOfInterest(mDetectionAndTrackingRect, mDetectionAndTrackingRect);
}
mVideoBackgroundChanged = false;
}
// Clear the content of the displayed words
foreach (var dw in mDisplayedWords)
{
dw.text = "";
}
// Update the list of words displayed
int wordIndex = 0;
foreach (var word in mSortedWords)
{
if (word.Word != null && wordIndex < mDisplayedWords.Length)
{
mDisplayedWords [wordIndex].text = word.Word.StringValue;
}
wordIndex++;
}
}
}
private void SignupForTextChanges(DocumentId documentId, SourceTextContainer textContainer, bool isCurrentContext, Action<Workspace, DocumentId, SourceText, PreservationMode> onChangedHandler)
{
var tracker = new TextTracker(this, documentId, textContainer, onChangedHandler);
_textTrackers.Add(documentId, tracker);
this.UpdateCurrentContextMapping_NoLock(textContainer, documentId, isCurrentContext);
tracker.Connect();
}
private void StopQCAR()
{
Debug.Log("StopQCAR");
MarkerTracker tracker = TrackerManager.Instance.GetTracker <MarkerTracker>();
if (tracker != null)
{
tracker.Stop();
}
ImageTracker tracker2 = TrackerManager.Instance.GetTracker <ImageTracker>();
if (tracker2 != null)
{
tracker2.Stop();
}
TextTracker tracker3 = TrackerManager.Instance.GetTracker <TextTracker>();
if (tracker3 != null)
{
tracker3.Stop();
}
this.CameraDirection = CameraDevice.Instance.GetCameraDirection();
CameraDevice.Instance.Stop();
CameraDevice.Instance.Deinit();
QCARRenderer.Instance.ClearVideoBackgroundConfig();
}
// 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();
}
}
void Update()
{
if (mIsInitialized)
{
// Once the text tracker has initialized and every time the video background changed,
// set the region of interest
if (mVideoBackgroundChanged)
{
TextTracker textTracker = TrackerManager.Instance.GetTracker <TextTracker>();
if (textTracker != null)
{
CalculateLoupeRegion();
textTracker.SetRegionOfInterest(mDetectionAndTrackingRect, mDetectionAndTrackingRect);
}
mVideoBackgroundChanged = false;
}
// Clear the content of the displayed words
/*foreach (var dw in mDisplayedWords)
* {
* dw.text = "";
* }*/
// Update the list of words displayed
mSortedWords.RemoveAll(p => string.IsNullOrEmpty(p.Word.StringValue));
for (int i = 0; i < mSortedWords.Count; i++)
{
var word = mSortedWords[i];
if (word.Word != null && !string.IsNullOrEmpty(word.Word.StringValue) && itemId != word.Word.StringValue)
{
itemId = word.Word.StringValue;
lastSeenItem = ItemSynthesizer.Synthesize(itemId);
UnityEngine.UI.Image buttonImage = GameObject.Find("ButtonImage").GetComponent <UnityEngine.UI.Image>();
if (lastSeenItem != null)
{
//mDisplayedWords[0].text = lastSeenItem.id;
Debug.Log(lastSeenItem);
if (buttonImage != null)
{
buttonImage.sprite = inventoryHandler.m_icons.Find(sprite => sprite.name.Equals(lastSeenItem.id));
questManager.SetLastSeenImage(buttonImage);
questManager.SetLastSeenItem(lastSeenItem.id);
}
}
}
}
if (mSortedWords.Count == 0)
{
UnityEngine.UI.Image buttonImage = GameObject.Find("ButtonImage").GetComponent <UnityEngine.UI.Image>();
buttonImage.sprite = inventoryHandler.m_icons.Find(sprite => sprite.name == "empty");
}
}
}
private void StopTextTracker()
{
Debug.Log("Stopping Text Tracker");
TextTracker tracker = TrackerManager.Instance.GetTracker <TextTracker>();
if (tracker != null)
{
tracker.Stop();
}
}
void Update()
{
if (videoBackgroundChanged)
{
Debug.Log("ROI Added");
TextTracker textTracker = (TextTracker)TrackerManager.Instance.GetTracker <TextTracker> ();
textTracker.SetRegionOfInterest(detectionRect, trackingRect);
videoBackgroundChanged = false;
}
}
public void UpdateHandler()
{
// once the text tracker has initialized and every time the video background changed, set the region of interest
if (mIsInitialized && mVideoBackgroundChanged)
{
TextTracker textTracker = TrackerManager.Instance.GetTracker <TextTracker>();
if (textTracker != null)
{
CalculateLoupeRegion();
textTracker.SetRegionOfInterest(mDetectionAndTrackingRect, mDetectionAndTrackingRect);
}
mVideoBackgroundChanged = false;
}
}
void InitTracker()
{
TextTracker textTracker = (TextTracker)TrackerManager.Instance.GetTracker <TextTracker>();
// text reco region of interest defined in screen coordinates:
Rect regionOfInterestTracking = new Rect(Vector2.zero, new Vector2(Screen.width, Screen.height));
Rect regionOfInterestDetection = new Rect(Screen.width * 0.2f, Screen.height * 0.2f,
Screen.width * 0.6f, Screen.height * 0.2f);
textTracker.SetRegionOfInterest(regionOfInterestDetection, regionOfInterestTracking);
//detector.anchoredPosition = regionOfInterestDetection.position;
//detector.sizeDelta = regionOfInterestDetection.size;
//tracker.anchoredPosition = regionOfInterestTracking.position;
//tracker.sizeDelta = regionOfInterestTracking.size;
}
private void OnDestroy()
{
QCARAbstractBehaviour behaviour = (QCARAbstractBehaviour)UnityEngine.Object.FindObjectOfType(typeof(QCARAbstractBehaviour));
if (behaviour != null)
{
behaviour.UnregisterTrackerEventHandler(this);
}
TextTracker tracker = TrackerManager.Instance.GetTracker <TextTracker>();
if (tracker != null)
{
tracker.WordList.UnloadAllLists();
}
}
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();
}
}
void Update()
{
if (mIsInitialized)
{
// Once the text tracker has initialized and every time the video background changed,
// set the region of interest
if (mVideoBackgroundChanged)
{
TextTracker textTracker = TrackerManager.Instance.GetTracker <TextTracker>();
if (textTracker != null)
{
CalculateLoupeRegion();
textTracker.SetRegionOfInterest(mDetectionAndTrackingRect, mDetectionAndTrackingRect);
}
mVideoBackgroundChanged = false;
}
// Update the list of words displayed
//maxBBHeight is set at this point
maxBBHeight = 0;
searchURL = "";
foreach (var word in mSortedWords)
{
if (word.Word != null && word.Word.Size.y > maxBBHeight)
{
maxBBHeight = word.Word.Size.y;
}
}
foreach (var word in mSortedWords)
{
if (word.Word != null)
{
temp = word.Word;
if (temp.Size.y >= maxBBHeight * 0.7)
{
searchURL += "+" + temp.StringValue;
}
}
}
searchText.text = searchURL.Substring(1);
searchURL = "https://www.google.com/search?tbm=bks&q=" + searchURL.Substring(1); //the search url
}
}
// 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 SetupWordList()
{
TextTracker tracker = TrackerManager.Instance.GetTracker <TextTracker>();
if (tracker != null)
{
WordList wordList = tracker.WordList;
wordList.LoadWordListFile(this.mWordListFile);
if (this.mCustomWordListFile != "")
{
wordList.AddWordsFromFile(this.mCustomWordListFile);
}
if (this.mAdditionalCustomWords != null)
{
foreach (string str in this.mAdditionalCustomWords.Split(new char[] { '\r', '\n' }))
{
if (str.Length > 0)
{
wordList.AddWord(str);
}
}
}
wordList.SetFilterMode(this.mFilterMode);
if (this.mFilterMode != WordFilterMode.NONE)
{
if (this.mFilterListFile != "")
{
wordList.LoadFilterListFile(this.mFilterListFile);
}
if (this.mAdditionalFilterWords != null)
{
foreach (string str2 in this.mAdditionalFilterWords.Split(new char[] { '\n' }))
{
if (str2.Length > 0)
{
wordList.AddWordToFilterList(str2);
}
}
}
}
}
}
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));
}
void Start()
{
textTracker = (TextTracker)TrackerManager.Instance.GetTracker <TextTracker>();
timetableEmpty();
}
// 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;
}
}
protected internal void OnDocumentOpened(DocumentId documentId, SourceTextContainer textContainer, bool isCurrentContext = true)
{
CheckDocumentIsInCurrentSolution(documentId);
CheckDocumentIsClosed(documentId);
using (this.serializationLock.DisposableWait())
{
var oldSolution = this.CurrentSolution;
var oldDocument = oldSolution.GetDocument(documentId);
var oldText = oldDocument.GetTextAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);
using (this.stateLock.DisposableWrite())
{
var openDocuments = GetProjectOpenDocuments_NoLock(documentId.ProjectId);
if (openDocuments != null)
{
openDocuments.Add(documentId);
}
else
{
this.projectToOpenDocumentsMap.Add(documentId.ProjectId, new HashSet <DocumentId> {
documentId
});
}
}
// keep open document text alive by using PreserveIdentity
var newText = textContainer.CurrentText;
var currentSolution = oldSolution;
if (oldText != newText)
{
if (oldText.ContentEquals(newText))
{
// if the supplied text is the same as the previous text, then add with same version
var version = oldDocument.GetTextVersionAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);
var newTextAndVersion = TextAndVersion.Create(newText, version, oldDocument.FilePath);
currentSolution = oldSolution.WithDocumentText(documentId, newTextAndVersion, PreservationMode.PreserveIdentity);
}
else
{
currentSolution = oldSolution.WithDocumentText(documentId, newText, PreservationMode.PreserveIdentity);
}
}
var newSolution = this.SetCurrentSolution(currentSolution);
var tracker = new TextTracker(this, documentId, textContainer);
this.textTrackers.Add(documentId, tracker);
this.AddTextToDocumentIdMapping_NoLock(textContainer, documentId, isCurrentContext);
tracker.Connect();
var newDoc = newSolution.GetDocument(documentId);
this.OnDocumentTextChanged(newDoc);
this.RaiseWorkspaceChangedEventAsync(WorkspaceChangeKind.DocumentChanged, oldSolution, newSolution, documentId: documentId);
var tsk = this.RaiseDocumentOpenedEventAsync(newDoc); // don't await this
}
// register outside of lock since it may call user code.
this.RegisterText(textContainer);
}
void Start()
{
textTracker = (TextTracker)TrackerManager.Instance.GetTracker <TextTracker>();
}
