private void HandleCalibrationDataCommand(INetworkConnection connection, string command, BinaryReader reader, int remainingDataSize) { int calibrationDataPayloadLength = reader.ReadInt32(); byte[] calibrationDataPayload = reader.ReadBytes(calibrationDataPayloadLength); CalculatedCameraCalibration calibration; if (CalculatedCameraCalibration.TryDeserialize(calibrationDataPayload, out calibration)) { if (sharedSpatialCoordinateProxy == null) { sharedSpatialCoordinateProxy = new GameObject("App HMD Shared Spatial Coordinate"); sharedSpatialCoordinateProxy.transform.SetParent(transform, worldPositionStays: true); if (appDeviceObserver != null && appDeviceObserver.NetworkConnection != null && SpatialCoordinateSystemManager.IsInitialized && SpatialCoordinateSystemManager.Instance.TryGetSpatialCoordinateSystemParticipant(appDeviceObserver.NetworkConnection, out SpatialCoordinateSystemParticipant participant)) { sharedSpatialCoordinateProxy.transform.position = participant.PeerSpatialCoordinateWorldPosition; sharedSpatialCoordinateProxy.transform.rotation = participant.PeerSpatialCoordinateWorldRotation; } } compositionManager.EnableHolographicCamera(sharedSpatialCoordinateProxy.transform, new CalibrationData(calibration.Intrinsics, calibration.Extrinsics)); } else { Debug.LogError("Received a CalibrationData packet from the HoloLens that could not be understood."); } }
private async void UploadCalibrationDataAsync(SocketEndpoint endpoint, string command, BinaryReader reader, int remainingDataSize) { bool succeeded = true; string uploadMessage = "Successfully uploaded calibration data."; Debug.Log("Received a calibration data payload"); var size = reader.ReadInt32(); var data = reader.ReadBytes(size); if (CalculatedCameraCalibration.TryDeserialize(data, out var calibrationData)) { var fileName = "CalibrationData.json"; Windows.Storage.StorageFile file = await Windows.Storage.KnownFolders.PicturesLibrary.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); await Windows.Storage.FileIO.WriteBytesAsync(file, data); } else { succeeded = false; uploadMessage = "Uploading calibration data failed - failed to deserialize calibration data."; Debug.LogError(uploadMessage); } SendUploadResult(succeeded, uploadMessage); }
private async void SendCalibrationDataAsync() { using (MemoryStream memoryStream = new MemoryStream()) using (BinaryWriter message = new BinaryWriter(memoryStream)) { StorageFile file = (await KnownFolders.PicturesLibrary.TryGetItemAsync(@"CalibrationData.json").AsTask()) as StorageFile; if (file != null) { byte[] contents = (await FileIO.ReadBufferAsync(file)).ToArray(); if (CalculatedCameraCalibration.TryDeserialize(contents, out CalculatedCameraCalibration calibration)) { // Magic offset from Unity's underlying coordinate frame (WorldManager.GetNativeISpatialCoordinateSystemPtr()) and the head pose used for the camera. // Poses are sent in the coordinate frame space because the Unity camera position uses prediction. Matrix4x4 viewFromWorld = calibration.Extrinsics.ViewFromWorld; Vector3 position = viewFromWorld.GetColumn(3); position += new Vector3(0f, 0.08f, 0.08f); viewFromWorld.SetColumn(3, position); calibration.Extrinsics.ViewFromWorld = viewFromWorld; contents = calibration.Serialize(); } message.Write("CalibrationData"); message.Write(contents.Length); message.Write(contents); networkManager.Broadcast(memoryStream.GetBuffer(), 0, memoryStream.Position); } } }
public static CalculatedCameraCalibration LoadCameraCalibration(string path) { if (File.Exists(path)) { var fileData = File.ReadAllBytes(path); if (CalculatedCameraCalibration.TryDeserialize(fileData, out var calibration)) { return(calibration); } } Debug.LogError($"Failed to load camera extrinsics file {path}"); return(null); }
public static string SaveCameraCalibration(CalculatedCameraCalibration calibration) { string path = Path.Combine(GetDocumentsFolderPath(), RootDirectoryName, $"CalibrationData.json"); int i = 0; while (File.Exists(path)) { path = Path.Combine(GetDocumentsFolderPath(), RootDirectoryName, $"CalibrationData_{i}.json"); i++; } var payload = calibration.Serialize(); File.WriteAllBytes(path, payload); return(path); }
/// <summary> /// Attempts to create a CalculatedCameraCalibration given a byte payload. /// </summary> /// <param name="payload">input byte payload</param> /// <param name="calibrationData">output calibration data</param> /// <returns>Returns true if the payload was successfully used to generate calibration data, otherwise false</returns> public static bool TryDeserialize(byte[] payload, out CalculatedCameraCalibration calibrationData) { calibrationData = null; try { var str = Encoding.UTF8.GetString(payload); calibrationData = JsonUtility.FromJson <CalculatedCameraCalibration>(str); return(calibrationData.Extrinsics != null && calibrationData.Intrinsics != null && calibrationData.Intrinsics.ImageWidth > 0 && calibrationData.Intrinsics.ImageHeight > 0); } catch (Exception e) { Debug.LogWarning($"Exception thrown deserializing camera intrinsics: {e.ToString()}"); return(false); } }
private void SendCalibrationData() { if (UnityCompositorInterface.IsCameraCalibrationInformationAvailable()) { UnityCompositorInterface.GetCameraCalibrationInformation(out CompositorCameraIntrinsics compositorIntrinsics); CalculatedCameraCalibration calibration = new CalculatedCameraCalibration(compositorIntrinsics.AsCalculatedCameraIntrinsics(), new CalculatedCameraExtrinsics()); byte[] serializedCalibration = calibration.Serialize(); using (MemoryStream memoryStream = new MemoryStream()) using (BinaryWriter message = new BinaryWriter(memoryStream)) { message.Write("CalibrationData"); message.Write(serializedCalibration.Length); message.Write(serializedCalibration); memoryStream.TryGetBuffer(out var buffer); networkManager.Broadcast(buffer.Array, buffer.Offset, buffer.Count); } } else { Debug.LogError($"Expected that calibration data should be available when the {nameof(StationaryCameraCalibrationDataProvider)} component is enabled, but calibration data was not available"); } }
/// <summary> /// Call to calculate camera extrinsics based on all obtained and usable datasets. /// </summary> public void CalculateExtrinsics() { if (processedDatasetCount > 0) { Debug.Log("Starting Individual Camera Extrinsics calculations."); cameraExtrinsics = CalibrationAPI.Instance.CalculateIndividualArUcoExtrinsics(dslrIntrinsics, parentVisuals.Count); if (cameraExtrinsics != null) { CreateExtrinsicsVisual(cameraExtrinsics); } Debug.Log("Completed Individual Camera Extrinsics calculations."); Debug.Log("Starting the Global Camera Extrinsics calculation."); globalExtrinsics = CalibrationAPI.Instance.CalculateGlobalArUcoExtrinsics(dslrIntrinsics); if (globalExtrinsics != null) { globalExtrinsicsFileName = CalibrationDataHelper.SaveCameraExtrinsics(globalExtrinsics); Debug.Log($"Saved global extrinsics: {globalExtrinsicsFileName}"); Debug.Log($"Found global extrinsics: {globalExtrinsics}"); var position = globalExtrinsics.ViewFromWorld.GetColumn(3); var rotation = Quaternion.LookRotation(globalExtrinsics.ViewFromWorld.GetColumn(2), globalExtrinsics.ViewFromWorld.GetColumn(1)); GameObject camera = null; cameraVisualHelper.CreateOrUpdateVisual(ref camera, position, rotation); camera.name = "Global Extrinsics"; GameObject hololens = null; cameraVisualHelper.CreateOrUpdateVisual(ref hololens, Vector3.zero, Quaternion.identity); hololens.name = "Global HoloLens"; lastCalibration = new CalculatedCameraCalibration(dslrIntrinsics, globalExtrinsics); calibrationFileName = CalibrationDataHelper.SaveCameraCalibration(lastCalibration); } } else { Debug.LogWarning("No usable marker datasets have been processed, unable to calculate camera extrinsics."); } }