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.");
}
}
