public static Vector2 GetPositionOfInterestPoint(int ip_internal_id)
{
HandledArray <float> position = new HandledArray <float>(2);
PikkartARCore.GetPositionOfInterestPoint(ip_internal_id, position.GetArray());
return(new Vector2(position.GetArray()[0], position.GetArray()[1]));
}
/// <summary>
/// Stops the recognition.
/// </summary>
public void StopRecognition()
{
stopTimers();
PikkartARCore.StopEffect();
PikkartARCore.StopRecognition();
_recognitionRunning = false;
}
public void SaveLocalMarkerThread(Marker marker, bool isRecognitionManagerRunning, bool replace, string appdatapath, bool sync_after_save)
{
if (replace || !File.Exists(appdatapath + "markers/" + marker.markerId + ".dat"))
{
string dstMarkerPath = appdatapath + "markers/";
if (!Directory.Exists(dstMarkerPath))
{
Directory.CreateDirectory(dstMarkerPath);
}
if (isRecognitionManagerRunning)
{
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
String sbId = marker.markerId.ToString();
String sbDescriptor = marker.markerDescriptor;
#else
StringBuilder sbId = new StringBuilder(marker.markerId.ToString());
StringBuilder sbDescriptor = new StringBuilder(marker.markerDescriptor);
#endif
PikkartARCore.SaveLocalMarker(sbId, sbDescriptor);
}
else
{
SaveLocalMarkerFile(marker.markerId, Convert.FromBase64String(marker.markerDescriptor));
}
if (sync_after_save)
{
PikkartARCore.SyncMarkersWithFolder();
}
}
marker.markerDescriptor = null;
_localRecognitionService.SaveMarker(marker, true /*_localRecognitionService.GetMarker(marker.markerId) != null*/);
}
public void ChangeRecognitionOptions(RecognitionOptions recognitionOptions)
{
if (_recognitionRunning)
{
if (_currentRecognitionOptions.getStorage() != recognitionOptions.getStorage())
{
if (recognitionOptions.getStorage() != RecognitionOptions.RecognitionStorage.LOCAL)
{
PikkartARCore.StartEffect();
}
else
{
PikkartARCore.StopEffect();
}
PikkartARCore.ChangeMode(recognitionOptions.getStorage() != RecognitionOptions.RecognitionStorage.LOCAL);
}
if (_currentRecognitionOptions.getMode() != recognitionOptions.getMode())
{
if (recognitionOptions.getMode() != RecognitionOptions.RecognitionMode.TAP_TO_SCAN)
{
stopTimers();
}
else
{
scheduleTimers();
}
}
}
_currentRecognitionOptions = recognitionOptions;
}
/// <summary>
/// Starts the native service recognition.
/// </summary>
/// <param name="recognitionOptions">Recognition options.</param>
/// <param name="recognitionListener">Recognition listener(MainScript).</param>
public void StartRecognition(RecognitionOptions recognitionOptions, IRecognitionListener recognitionListener)
{
StopRecognition();
SyncMarkersWithFolder();
_recognitionRunning = true;
_active = true;
_currentRecognitionOptions = recognitionOptions;
_recognitionListener = recognitionListener;
_dataProvider = new RecognitionDataProvider(recognitionOptions.getCloudInfo(), this, GetDeviceId());
#if !UNITY_EDITOR
if (!LoadSavedCameraParams())
{
_dataProvider.ExecuteGetCameraParamFromServer(true);
}
#endif
PikkartARCore.ChangeMode(_currentRecognitionOptions.getStorage() != RecognitionOptions.RecognitionStorage.LOCAL);
PikkartARCore.StartRecognition(_currentRecognitionOptions.getStorage() != RecognitionOptions.RecognitionStorage.LOCAL, false);
PikkartARCore.StartEffect();
_markerId = "";
if (_currentRecognitionOptions.getMode() == RecognitionOptions.RecognitionMode.TAP_TO_SCAN)
{
scheduleTimers();
}
}
public void DeleteOldestMarkers(int markerToDeleteCount, String markerToSaveId,
bool isRecognitionRunning)
{
List <Marker> markers = dbu.MarkerQuery("SELECT markerId FROM " +
"Markers WHERE markerId<>'" + markerToSaveId + "' AND " +
"databaseId IN (SELECT id FROM MarkerDatabase " +
" WHERE cloud=1) ORDER BY lastAccessDate DESC LIMIT " + markerToDeleteCount);
foreach (Marker marker in markers)
{
dbu.Delete <Marker>(marker.markerId);
if (isRecognitionRunning)
{
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
PikkartARCore.DeleteLocalMarker(marker.markerId, true);
#else
PikkartARCore.DeleteLocalMarker(new StringBuilder(marker.markerId), true);
#endif
}
else
{
File.Delete(StorageUtils.GetApplicationPersistentDataPath() + "markers/" + marker.markerId + ".dat");
}
}
}
void OnScreenDataChange(ScreenData screen)
{
int angle = 0;
switch (DeviceOrientationChange.GetDeviceOrientation())
{
case DeviceOrientation.LandscapeLeft:
RotateLandscapeLeft();
angle = 0;
break;
case DeviceOrientation.LandscapeRight:
RotateLandscapeRight();
angle = 180;
break;
case DeviceOrientation.Portrait:
RotatePortrait();
angle = 90;
break;
case DeviceOrientation.PortraitUpsideDown:
RotatePortaitUpsideDown();
angle = 270;
break;
}
PikkartARCore.UpdateViewport((int)screen.resolution.x, (int)screen.resolution.y, angle);
}
public static String GetInterestPointPublicID(int ip_internal_id)
{
IntPtr ipFoundPtr = Marshal.AllocHGlobal(512);
int size = PikkartARCore.GetInterestPointPublicID(ip_internal_id, ipFoundPtr);
String ipFound = Marshal.PtrToStringAnsi(ipFoundPtr, size - 1);
return(ipFound);
}
public void UploadCameraDataAsOpenGLTexture()
{
if (webcamTexture != null && webcamTexture.isPlaying)
{
IntPtr gl_id = webcamTexture.GetNativeTexturePtr();
PikkartARCore.CopyNewFrameFromGL(gl_id, Constants.CAMERA_REQUESTED_WIDTH, Constants.CAMERA_REQUESTED_HEIGHT);
}
}
public void UploadCameraDataAsColor32()
{
if (webcamTexture != null && webcamTexture.isPlaying)
{
webcamTexture.GetPixels32(data);
}
PikkartARCore.CopyNewFrame32(data, Constants.CAMERA_REQUESTED_WIDTH, Constants.CAMERA_REQUESTED_HEIGHT);
}
public void ForceMarkerSearch(string markerId)
{
ChangeRecognitionOptions(new RecognitionOptions(RecognitionOptions.RecognitionStorage.LOCAL, RecognitionOptions.RecognitionMode.CONTINUOUS_SCAN, null));
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
PikkartARCore.ForceMarkerSearch(markerId.ToString());
#else
PikkartARCore.ForceMarkerSearch(new StringBuilder(markerId.ToString()));
#endif
}
/// <summary>
/// Deletes the marker.
/// </summary>
/// <param name="marker">Marker object.</param>
public void DeleteMarker(Marker marker)
{
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
PikkartARCore.DeleteLocalMarker(marker.markerId, true);
#else
PikkartARCore.DeleteLocalMarker(new StringBuilder(marker.markerId), true);
#endif
dbu.Delete <Marker>(marker);
}
public static bool LoadDiscoverModel(string modelname)
{
Debug.Log("Loading discover model " + modelname);
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
String sbId = modelname.ToString();
#else
StringBuilder sbId = new StringBuilder(modelname.ToString());
#endif
return(PikkartARCore.LoadDiscoverModel(sbId));
}
public static int[] GetActiveInterestPoints()
{
HandledArray <int> ipIds = new HandledArray <int>(10);
int sz = PikkartARCore.GetActiveInterestPoints(ipIds.GetArray());
int[] ret = new int[sz];
for (int i = 0; i < sz; ++i)
{
ret[i] = ipIds.GetArray()[i];
}
return(ret);
}
public void UpdateVisibleFrame()
{
#if UNITY_EDITOR
PikkartARCore.UpdateCameraTexture(imagePtr_receive);
#endif
if (textureToShow != null)
{
textureToShow.LoadRawTextureData(imagePtr_receive, Constants.CAMERA_REQUESTED_WIDTH * Constants.CAMERA_REQUESTED_HEIGHT * 4);
textureToShow.Apply();
if (rawImage != null)
{
rawImage.texture = textureToShow;
}
}
}
public void InitWebcam(bool front_facing)
{
if (rawImage == null)
{
rawImage = GetComponent <RawImage>();
if (rawImage != null)
{
rawImage.texture = Texture2D.blackTexture;
}
}
if (textureToShow == null)
{
textureToShow = new Texture2D(Constants.CAMERA_REQUESTED_WIDTH,
Constants.CAMERA_REQUESTED_HEIGHT,
TextureFormat.RGBA32,
false);
textureToShow.Apply();
}
#if !UNITY_EDITOR
PikkartARCore.CameraUpdateUnityTextureId_GL(textureToShow.GetNativeTexturePtr());
#endif
#if UNITY_EDITOR
PikkartARCore.UpdateViewport((int)Constants.CAMERA_REQUESTED_WIDTH, (int)Constants.CAMERA_REQUESTED_HEIGHT, 0);
#endif
DeviceOrientationChange.OnScreenDataChange += OnScreenDataChange;
portraitScale = new Vector3(
(float)Constants.CAMERA_REQUESTED_HEIGHT / (float)Constants.CAMERA_REQUESTED_WIDTH,
(float)Constants.CAMERA_REQUESTED_HEIGHT / (float)Constants.CAMERA_REQUESTED_WIDTH,
1.0f);
data = null;
imagePtr_send = IntPtr.Zero;
imagePtr_receive = Marshal.AllocHGlobal(Constants.CAMERA_REQUESTED_WIDTH * Constants.CAMERA_REQUESTED_HEIGHT * 4);
webcamTexture = GetManagedWebCamTexture(front_facing);
if (rawImage != null)
{
rawImage.texture = textureToShow;
}
initialized_manager = true;
OnScreenDataChange(DeviceOrientationChange.GetUpdatedDeviceOrientation());
}
public void GetCameraParamCallback(double[] cam_params, bool save)
{
if (cam_params[0] != -1.0)
{
if (save)
{
SaveCameraParams(cam_params);
}
PikkartARCore.SetProjectionMatrix2((float)cam_params[0],
(float)cam_params[1],
(float)cam_params[2],
(float)cam_params[3]);
_pikk_camera.SetCameraParameters(cam_params[0], cam_params[1], cam_params[2], cam_params[3]);
}
}
public static Matrix4x4 GetAlternateLandscapeProjectionMatrix()
{
//Debug.Log("landscape hfov=" + Constants.CAM_LARGE_FOV + " vfov=" + Constants.CAM_SMALL_FOV);
float[] mat_data = new float[16];
PikkartARCore.GetProjectionMatrix(mat_data);
/*alternateLandscapeProjectionMatrix.m00 = mat_data[0];
* alternateLandscapeProjectionMatrix.m01 = mat_data[1];
* alternateLandscapeProjectionMatrix.m02 = mat_data[2];
* alternateLandscapeProjectionMatrix.m03 = mat_data[3];
*
* alternateLandscapeProjectionMatrix.m10 = mat_data[4];
* alternateLandscapeProjectionMatrix.m11 = mat_data[5];
* alternateLandscapeProjectionMatrix.m12 = mat_data[6];
* alternateLandscapeProjectionMatrix.m13 = mat_data[7];
*
* alternateLandscapeProjectionMatrix.m20 = mat_data[8];
* alternateLandscapeProjectionMatrix.m21 = mat_data[9];
* alternateLandscapeProjectionMatrix.m22 = mat_data[10];
* alternateLandscapeProjectionMatrix.m23 = mat_data[11];
*
* alternateLandscapeProjectionMatrix.m30 = mat_data[12];
* alternateLandscapeProjectionMatrix.m31 = mat_data[13];
* alternateLandscapeProjectionMatrix.m32 = mat_data[14];
* alternateLandscapeProjectionMatrix.m33 = mat_data[15];*/
//horizontal field of view = 2 atan(0.5 width / focallength)
double v = 1.0 / (double)(mat_data[0]);
double at = Math.Atan(v);
double hfov = 2.0 * at;
float camera_ar = Constants.CAMERA_REQUESTED_WIDTH / Constants.CAMERA_REQUESTED_HEIGHT;
float t = ScreenUtilities.GetPortraitAspectRatio() * camera_ar * (float)Math.Tan(hfov / 2.0);
float a = 2.0f * (float)Math.Atan((double)(t)) * 57.2958f;
alternateLandscapeProjectionMatrix = Matrix4x4.Perspective(
a,
ScreenUtilities.GetLandscapeAspectRatio(),
Constants.NEAR_CLIP_PLANE,
Constants.FAR_CLIP_PLANE);
return(alternateLandscapeProjectionMatrix);
}
public void GetCameraParamsCallbackOK(WSCameraParamsResponse response)
{
double[] cam_params = new double[4];
byte[] byte_array;
byte_array = Convert.FromBase64String(response.data);
float[] paramsf = new float[4];
IntPtr byte_send;
byte_send = Marshal.AllocHGlobal(20);
Marshal.Copy(byte_array, 0, byte_send, 20);
PikkartARCore.DecryptCalibParams(byte_send, paramsf);
cam_params[0] = paramsf[0];
cam_params[1] = paramsf[1];
cam_params[2] = paramsf[2];
cam_params[3] = paramsf[3];
_dataProviderListener.GetCameraParamCallback(cam_params, true);
_getMarkerRequestRunning = false;
}
/// <summary>
/// Instructs the cloud recognition service to execute a FindMarker request.
/// </summary>
/// <param name="imageBase64">Image base64.</param>
public void ExecuteFindMarkerRequest()
{
if (_findMarkerRequestRunning)
{
return;
}
_findMarkerRequestRunning = true;
int size = PikkartARCore.GetUpdatedServerBuffer(_nativeArray);
if (size == 0)
{
_findMarkerRequestRunning = false;
return;
}
string imageDescriptor = Marshal.PtrToStringAnsi(_nativeArray);
PikkartARHelper.Instance.LaunchCoroutine(_cloudRecognitionService.FindMarker(imageDescriptor, FindMarkerCallbackOK, FindMarkerCallbackKO));
}
/*
* CreateServerSignature
*/
public static string AuthorizationCode(string method, string body, string date, string path)
{
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
PikkartARCore.CreateUnityServerSignature(method, body, date, path, signaturePtr);
string signature_str = Marshal.PtrToStringAuto(signaturePtr);
#else
PikkartARCore.CreateUnityServerSignature(new StringBuilder(method), new StringBuilder(body),
new StringBuilder(date), new StringBuilder(path), signaturePtr);
string signature_str = Marshal.PtrToStringAnsi(signaturePtr);
#endif
if (signature_str != null && signature_str.Length >= SIGNATURE_LENGTH)
{
string signature = signature_str.ToString().Substring(0, SIGNATURE_LENGTH);
return(signature);
}
else
{
Debug.Log("signature=" + signature_str);
return("");
}
}
public static Matrix4x4 GetAlternatePortraitProjectionMatrix()
{
//Debug.Log("portrait hfov=" + Constants.CAM_LARGE_FOV + " vfov=" + Constants.CAM_SMALL_FOV);
float[] mat_data = new float[16];
PikkartARCore.GetProjectionMatrix(mat_data);
/*alternateLandscapeProjectionMatrix.m00 = mat_data[0];
* alternateLandscapeProjectionMatrix.m01 = mat_data[1];
* alternateLandscapeProjectionMatrix.m02 = mat_data[2];
* alternateLandscapeProjectionMatrix.m03 = mat_data[3];
*
* alternateLandscapeProjectionMatrix.m10 = mat_data[4];
* alternateLandscapeProjectionMatrix.m11 = mat_data[5];
* alternateLandscapeProjectionMatrix.m12 = mat_data[6];
* alternateLandscapeProjectionMatrix.m13 = mat_data[7];
*
* alternateLandscapeProjectionMatrix.m20 = mat_data[8];
* alternateLandscapeProjectionMatrix.m21 = mat_data[9];
* alternateLandscapeProjectionMatrix.m22 = mat_data[10];
* alternateLandscapeProjectionMatrix.m23 = mat_data[11];
*
* alternateLandscapeProjectionMatrix.m30 = mat_data[12];
* alternateLandscapeProjectionMatrix.m31 = mat_data[13];
* alternateLandscapeProjectionMatrix.m32 = mat_data[14];
* alternateLandscapeProjectionMatrix.m33 = mat_data[15];*/
double v = 1.0 / (double)(mat_data[0]);
double at = Math.Atan(v);
double hfov = 2.0 * at * 57.2958;
alternatePortraitProjectionMatrix = Matrix4x4.Perspective(
(float)hfov,
ScreenUtilities.GetPortraitAspectRatio(),
Constants.NEAR_CLIP_PLANE,
Constants.FAR_CLIP_PLANE);
return(alternatePortraitProjectionMatrix);
}
public bool LoadSavedCameraParams()
{
bool ret = PlayerPrefs.HasKey("cam_param1") &&
PlayerPrefs.HasKey("cam_param2") &&
PlayerPrefs.HasKey("cam_param3") &&
PlayerPrefs.HasKey("cam_param4");
if (ret)
{
float[] cam_params = new float[4];
cam_params[0] = PlayerPrefs.GetFloat("cam_param1");
cam_params[1] = PlayerPrefs.GetFloat("cam_param2");
cam_params[2] = PlayerPrefs.GetFloat("cam_param3");
cam_params[3] = PlayerPrefs.GetFloat("cam_param4");
PikkartARCore.SetProjectionMatrix2(cam_params[0],
cam_params[1],
cam_params[2],
cam_params[3]);
_pikk_camera.SetCameraParameters(cam_params[0], cam_params[1], cam_params[2], cam_params[3]);
}
return(ret);
}
/// <summary>
/// Locals the marker found. Called by PikkartARCamera instance.
/// </summary>
/// <param name="markerId">Marker identifier.</param>
public void LocalMarkerFound(string markerId, int marker_internal_id)
{
stopTimers();
if (_markerId == "" || _markerId != markerId)
{
_currentMarker = new MarkerInfo(markerId, marker_internal_id, (double)PikkartARCore.GetMarkerWidthInternalID(marker_internal_id),
(double)PikkartARCore.GetMarkerHeightInternalID(marker_internal_id));
_dataProvider.ExecuteGetMarkerRequest(markerId, false, true);
if (_currentRecognitionOptions.getMode() == RecognitionOptions.RecognitionMode.TAP_TO_SCAN)
{
ForceMarkerSearch(markerId);
_recognitionRunning = false;
}
}
else
{
_currentMarker.setARLogoCode(-1);
_markerObjectListener.OnMarkerFound(_currentMarker);
_recognitionListener.MarkerFound(_currentMarker);
}
}
/// <summary>
/// Deletes obsolete local data.
/// </summary>
/// <param name="cacheMilliseconds">Cache milliseconds.</param>
/// <param name="isRecognitionManagerRunning">is recognition manager running.</param>
public void DeleteObsoleteLocalData(bool deleteFilesNotInSqlite, bool isRecognitionManagerRunning)
{
List <string> markersFileNames = new List <string>();
List <Marker> dbMarkers = GetMarkersList();
string markersPath = RecognitionManager.GetAppDataPath() + "markers";
if (!Directory.Exists(markersPath))
{
Directory.CreateDirectory(markersPath);
}
if (dbMarkers.Count > 0)
{
foreach (Marker marker in dbMarkers)
{
string markerId = marker.markerId;
string markerFileName = markerId + ".dat";
DateTime?publishedTo = marker.publishedTo;
markersFileNames.Add(markerFileName);
if (publishedTo == null)
{
continue;
}
if (publishedTo.Value.CompareTo(DateTime.Now.ToUniversalTime()) < 0)
{
if (isRecognitionManagerRunning)
{
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
PikkartARCore.DeleteLocalMarker(markerId, true);
#else
PikkartARCore.DeleteLocalMarker(new StringBuilder(markerId), true);
#endif
}
else
{
string markerFilePath = markersPath + "/" + markerFileName;
if (!Directory.Exists(markersPath))
{
Directory.CreateDirectory(markersPath);
}
if (File.Exists(markerFilePath))
{
File.Delete(markerFilePath);
}
}
}
}
}
if (deleteFilesNotInSqlite)
{
var info = new DirectoryInfo(markersPath);
FileInfo[] filesInfo = info.GetFiles();
foreach (FileInfo fileInfo in filesInfo)
{
if (fileInfo.Name.Contains(".dat") && !markersFileNames.Contains(fileInfo.Name))
{
fileInfo.Delete();
}
}
}
dbu.DeleteObsoleteMarkers();
}
private IEnumerator CameraLoop()
{
camera_coroutine_running = true;
while (camera_coroutine_running)
{
camera_loop_running = true;
if (_webcam != null && _webcam.IsUpdated())
{
//Debug.Log("webcam Pikkart Camera Loop camera updated");
PikkartARCore.SetCameraOriginalSize(Constants.CAMERA_REQUESTED_WIDTH, Constants.CAMERA_REQUESTED_HEIGHT);
PikkartARCore.CopyNewFrame(_webcam.GetDataAsIntPtr(), _webcam.GetCameraWidth(), _webcam.GetCameraHeight());
//PikkartARCore.CopyNewFrame32(_webcam.GetDataAsColor32(), Constants.CAMERA_REQUESTED_WIDTH, Constants.CAMERA_REQUESTED_HEIGHT);
//_webcam.UploadCameraDataAsColor32();
bool found_something = PikkartARCore.ImageProcessing();
if (Screen.currentResolution.width > Screen.currentResolution.height)
{
if (cam != null)
{
cam.projectionMatrix = MatrixUtils.GetAlternateLandscapeProjectionMatrix();
}
}
else
{
if (cam != null)
{
cam.projectionMatrix = MatrixUtils.GetAlternatePortraitProjectionMatrix();
}
}
String markerFound = "";
int logo_payload = -1;
int numTrackedMarkers = 0;
if (found_something)
{
numTrackedMarkers = PikkartARCore.GetTrackedInternalIDs(trackedMarkersData.GetArray());
}
//Debug.Log("markerFound=numTrackedMarkers " + numTrackedMarkers);
if (numTrackedMarkers > 0)
{
int size = PikkartARCore.GetMarkerNameFromInternalIDs(trackedMarkersData.GetArray()[0], markerFoundPtr);
markerFound = Marshal.PtrToStringAnsi(markerFoundPtr, size - 1);
if (IsSeethroughDevice)
{
size = PikkartARCore.GetMarkerPoseInternalID_WithPrediction(trackedMarkersData.GetArray()[0], PredictionFrames, viewMatrixData.GetArray());
}
else
{
size = PikkartARCore.GetMarkerPoseInternalID(trackedMarkersData.GetArray()[0], viewMatrixData.GetArray());
}
logo_payload = PikkartARCore.MarkerHasLogoInternalId(trackedMarkersData.GetArray()[0]);
if (logo_payload > 0)
{
recognitionManager.ARLogoFound(trackedMarkersData.GetArray()[0], logo_payload);
}
else
{
logo_payload = -1;
}
}
else
{
markerFound = "";
}
if (markerFound == "")
{
if (recognitionManager != null)
{
if (recognitionManager.IsRecognitionRunning())
{
recognitionManager.LocalMarkerNotFound();
}
}
viewMatrix = Matrix4x4.identity;
}
else if (markerFound != "")
{
if (IsSeethroughDevice)
{
if (previousMarkerFound != "" && markerFound != previousMarkerFound)
{
recognitionManager.MarkerTrackingLost(previousMarkerFound);
}
}
if (recognitionManager != null && previousMarkerFound == "")
{
recognitionManager.LocalMarkerFound(markerFound, trackedMarkersData.GetArray()[0]);
}
viewMatrix = MatrixUtils.GetViewMatrixFromArray(viewMatrixData.GetArray());
viewMatrix = MatrixUtils.GetRotationMatrixForOrientation() * viewMatrix;
}
if (!IsSeethroughDevice)
{
if (previousMarkerFound != "" && markerFound == "")
{
recognitionManager.MarkerTrackingLost(previousMarkerFound);
}
}
previousMarkerFound = markerFound;
MarkerUpdate();
#if UNITY_EDITOR
_webcam.UpdateVisibleFrame();
#else
if (!IsSeethroughDevice)
{
GL.IssuePluginEvent(PikkartARCore.GetRenderEventFunc(), 666);
}
#endif
//Debug.Log("markerFound=" + markerFound);
}
//yield return new WaitUntil(() => _webcam!=null && _webcam.IsUpdated() == true);
//yield return null;
yield return(new WaitForEndOfFrame());
}
camera_loop_running = false;
}
protected void StopRecognition()
{
PikkartARCore.StopRecognition();
}
/// <summary>
/// Init this instance. Initialize and start RecongnitionManager, PikkartCamera and NatCamManager.
/// </summary>
protected IEnumerator InitRecognition()
{
foreach (var device in WebCamTexture.devices)
{
Debug.Log("Name: " + device.name);
}
yield return(Application.RequestUserAuthorization(UserAuthorization.WebCam));
if (Application.HasUserAuthorization(UserAuthorization.WebCam))
{
Debug.Log("webcam found");
}
else
{
#if UNITY_EDITOR
if (EditorUtility.DisplayDialog("Camera error!",
"You cannot use our SDK without a camera!\n" +
"Please connect a camera and try again.", "Ok"))
{
EditorApplication.isPlaying = false;
}
#endif
Debug.Log("webcam error no webcam");
yield break;
}
#if UNITY_EDITOR
if (!useWebcamOnEditor)
{
yield break;
}
#endif
Screen.sleepTimeout = SleepTimeout.NeverSleep;
foreach (CloudMarkerObject cloudMarker in _cloudMarkers)
{
cloudMarker.Init();
}
foreach (MarkerObject marker in _markerObjects)
{
marker.Init();
}
_camera = FindObjectOfType <PikkartARCamera>();
_webcam = FindObjectOfType <WebCamManager>();
if (_recognitionManager == null)
{
_recognitionManager = new RecognitionManager(this);
_recognitionManager.LoadLocalMarkersOnStartup(true, _markerList, _discoverList);
}
else
{
PikkartARCore.SyncMarkersWithFolder();
}
_camera.SetRecognitionManager(_recognitionManager);
_recognitionOptions = new RecognitionOptions(
recognitionStorage,
recognitionMode,
new CloudRecognitionInfo(databases));
if (_webcam.HasWebcam())
{
_camera.LaunchWebcam(_webcam);
}
else
{
#if UNITY_EDITOR
if (EditorUtility.DisplayDialog("Camera error!",
"You cannot use our SDK without a camera!\n" +
"Please connect a camera and try again.", "Ok"))
{
EditorApplication.isPlaying = false;
}
#endif
Debug.Log("webcam error no webcam");
}
#if UNITY_EDITOR
if (_recognitionOptions.getMode() != RecognitionOptions.RecognitionMode.TAP_TO_SCAN)
{
if (FindObjectOfType <ScanButton>() != null)
{
FindObjectOfType <ScanButton>().gameObject.SetActive(false);
}
}
#else
if (FindObjectOfType <ScanButton>() != null)
{
FindObjectOfType <ScanButton>().gameObject.SetActive(false);
}
#endif
_camera.SetMarkers(ref _markerObjects, ref _cloudMarkers);
_camera.SetSeeThroughDevice(isSeeThroughDevice, seeThroughFramePrediction);
if (_recognitionListener != null)
{
_recognitionListener.OnPikkartARStartupComplete();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PikkartAR.RecognitionManager"/> class.
/// </summary>
/// <param name="width">Frame Width.</param>
/// <param name="height">Frame Height.</param>
/// <param name="localRecognitionService">Object that implements the communication interface.</param>
public RecognitionManager(IMarkerObjectListener markerObjectListener)
{
_markerObjectListener = markerObjectListener;
_recognitionRunning = false;
#if UNITY_ANDROID && !UNITY_EDITOR
AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
AndroidJavaObject context = jc.GetStatic <AndroidJavaObject>("currentActivity");
AndroidJavaObject assetManager = context.Call <AndroidJavaObject>("getAssets");
#endif
_deviceId = RecognitionManager.GetDeviceId();
// Native Recognition Service Initialization
if (!_nativeWrapperInitialized)
{
int res = PikkartARCore.InitRecognition(
#if UNITY_ANDROID && !UNITY_EDITOR
assetManager.GetRawObject(),
#endif
_localMarkerNotFoundEventMinIntervalMillisecs,
#if UNITY_EDITOR_OSX || (UNITY_IOS && !UNITY_EDITOR_WIN)
GetAppDataPath(),
#else
new StringBuilder(GetAppDataPath()),
#endif
#if UNITY_EDITOR_WIN
new StringBuilder(Application.streamingAssetsPath),
#if UNITY_5_6_OR_NEWER
new StringBuilder(PlayerSettings.applicationIdentifier),
#else
new StringBuilder(PlayerSettings.bundleIdentifier),
#endif
#elif UNITY_EDITOR_OSX
Application.streamingAssetsPath,
#if UNITY_5_6_OR_NEWER
PlayerSettings.applicationIdentifier,
#else
PlayerSettings.bundleIdentifier,
#endif
#endif
Constants.PROCESS_WIDTH,
Constants.PROCESS_HEIGHT,
ScreenUtilities.GetScreenInches(),
Constants.CAMERA_REQUESTED_WIDTH,
Constants.CAMERA_REQUESTED_HEIGHT,
false);
if (res > 0)
{
_licenceChecked = true;
}
else
{
_licenceChecked = false;
}
if (res == 0)
{
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
if (MonoBehaviour.FindObjectOfType <LicenseMessage>() != null)
{
MonoBehaviour.FindObjectOfType <LicenseMessage>().gameObject.SetActive(true);
}
if (MonoBehaviour.FindObjectOfType <TrialMessage>() != null)
{
MonoBehaviour.FindObjectOfType <TrialMessage>().gameObject.SetActive(false);
}
#elif UNITY_EDITOR
if (MonoBehaviour.FindObjectOfType <TrialMessage>() != null)
{
MonoBehaviour.FindObjectOfType <TrialMessage>().gameObject.SetActive(false);
}
if (MonoBehaviour.FindObjectOfType <LicenseMessage>() != null)
{
MonoBehaviour.FindObjectOfType <LicenseMessage>().gameObject.SetActive(false);
}
if (EditorUtility.DisplayDialog("Licence error!",
"You cannot use our sdk without a valid licence UNLESS you are in a trial!\n" +
"Please register to developer.pikkart.com to obtain your own licence or set your application identifier to 'com.pikkart.trial' to evaluate our SDK.", "Ok"))
{
EditorApplication.isPlaying = false;
}
#endif
}
else if (res == 1)
{
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
if (MonoBehaviour.FindObjectOfType <TrialMessage>())
{
MonoBehaviour.FindObjectOfType <TrialMessage>().gameObject.SetActive(true);
}
if (MonoBehaviour.FindObjectOfType <LicenseMessage>())
{
MonoBehaviour.FindObjectOfType <LicenseMessage>().gameObject.SetActive(false);
}
#elif UNITY_EDITOR
if (MonoBehaviour.FindObjectOfType <TrialMessage>())
{
MonoBehaviour.FindObjectOfType <TrialMessage>().gameObject.SetActive(false);
}
if (MonoBehaviour.FindObjectOfType <LicenseMessage>())
{
MonoBehaviour.FindObjectOfType <LicenseMessage>().gameObject.SetActive(false);
}
if (EditorUtility.DisplayDialog("No valid license",
"No valid license or running as com.pikkart.trial, press Ok to run in trial mode", "Ok"))
{
EditorApplication.isPlaying = true;
}
#endif
}
else
{
if (MonoBehaviour.FindObjectOfType <TrialMessage>())
{
MonoBehaviour.FindObjectOfType <TrialMessage>().gameObject.SetActive(false);
}
if (MonoBehaviour.FindObjectOfType <LicenseMessage>())
{
MonoBehaviour.FindObjectOfType <LicenseMessage>().gameObject.SetActive(false);
}
}
PikkartARCore.SetProjectionMatrix(Constants.CAM_LARGE_FOV, Constants.CAM_SMALL_FOV);
_nativeWrapperInitialized = true;
//_nativeArray = Marshal.AllocHGlobal(Constants.BASE_RES_WIDTH * Constants.BASE_RES_HEIGHT * 3);
}
else
{
if (MonoBehaviour.FindObjectOfType <TrialMessage>())
{
MonoBehaviour.FindObjectOfType <TrialMessage>().gameObject.SetActive(false);
}
if (MonoBehaviour.FindObjectOfType <LicenseMessage>())
{
MonoBehaviour.FindObjectOfType <LicenseMessage>().gameObject.SetActive(false);
}
}
_dataProvider = new RecognitionDataProvider(null, this, _deviceId);
}
public static void StopDiscover()
{
PikkartARCore.EnableDiscover(false);
}
