private void OnDataReceived(string playerId, byte[] payload)
{
if (HeadsetCalibrationDataRequest.TryDeserialize(payload, out request))
{
Debug.Log("Headset calibration data requested");
updateData = true;
}
else
{
Debug.LogWarning("Received network payload that wasn't a headset calibration data request");
request = null;
}
}
/// <summary>
/// Call to try and deserialize a byte array paylod to create a headset calibration data request.
/// </summary>
/// <param name="payload">byte array to deserialize</param>
/// <param name="request">output headset calibration data request</param>
/// <returns>Returns true if the payload was successfully converted to a headset calibration data request, otherwise false.</returns>
public static bool TryDeserialize(byte[] payload, out HeadsetCalibrationDataRequest request)
{
request = null;
try
{
var str = Encoding.UTF8.GetString(payload);
request = JsonUtility.FromJson <HeadsetCalibrationDataRequest>(str);
return(true);
}
catch (Exception e)
{
Debug.LogError($"Exception thrown: {e}");
return(false);
}
}
public static bool TryDeserialize(byte[] payload, out HeadsetCalibrationDataRequest request)
{
request = null;
try
{
var str = Encoding.UTF8.GetString(payload);
request = JsonUtility.FromJson <HeadsetCalibrationDataRequest>(str);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Call to read and deserialize a byte array paylod to create a headset calibration data request.
/// </summary>
/// <param name="reader">reader for obtaining the byte array to deserialize</param>
/// <param name="request">output headset calibration data request</param>
/// <returns>Returns true if the payload was successfully converted to a headset calibration data request, otherwise false.</returns>
public static bool TryDeserialize(BinaryReader reader, out HeadsetCalibrationDataRequest request)
{
request = null;
var str = reader.ReadString();
try
{
request = JsonUtility.FromJson <HeadsetCalibrationDataRequest>(str);
return(true);
}
catch (Exception e)
{
Debug.LogError($"Exception thrown: {e}");
return(false);
}
}
private void CalibrationDataRequested(SocketEndpoint endpoint, string command, BinaryReader reader, int remainingDataSize)
{
editorAddress = endpoint.Address;
EnableChildren();
if (HeadsetCalibrationDataRequest.TryDeserialize(reader, out request))
{
Debug.Log("Headset calibration data requested");
updateData = true;
}
else
{
Debug.LogWarning("Received network payload that wasn't a headset calibration data request");
request = null;
}
}
/// <summary>
/// Call to request another dataset from the connected HoloLens device.
/// </summary>
public void RequestHeadsetData()
{
if (holographicCameraObserver != null &&
holographicCameraObserver.IsConnected)
{
using (MemoryStream memoryStream = new MemoryStream())
using (BinaryWriter writer = new BinaryWriter(memoryStream))
{
writer.Write(HeadsetCalibration.RequestCalibrationDataCommandHeader);
var request = new HeadsetCalibrationDataRequest();
request.timestamp = Time.time;
request.SerializeAndWrite(writer);
writer.Flush();
holographicCameraObserver.Broadcast(memoryStream.ToArray());
}
}
else
{
Debug.LogWarning("HolographicCameraObserver isn't setup correctly, failed to request headset data.");
}
}
private void Update()
{
if (feedImage != null &&
feedImage.texture == null)
{
feedImage.texture = CompositorWrapper.Instance.GetVideoCameraFeed();
}
if (Input.GetKeyDown(KeyCode.Space))
{
if (networkingService != null &&
matchMakingService != null)
{
var request = new HeadsetCalibrationDataRequest();
request.timestamp = Time.time;
var payload = request.Serialize();
if (networkingService.SendData(payload, NetworkPriority.Critical))
{
Debug.Log($"Sent headset calibration data request to HoloLens at {request.timestamp}");
}
else
{
Debug.LogWarning("Failed to send headset calibration data request to HoloLens");
}
}
if (headsetCalibration != null)
{
Debug.Log("Requesting headset calibration data from VR Headset");
headsetCalibration.UpdateHeadsetCalibrationData();
}
}
if (headsetData != null)
{
if (headsetData.markers.Count != expectedNumberOfMarkers)
{
Debug.Log("Headset has not yet detected all of the markers on the calibration board, dropping payload from headset.");
}
else
{
var dslrTexture = CompositorWrapper.Instance.GetVideoCameraTexture();
var fileName = CalibrationDataHelper.GetUniqueFileName();
CalibrationDataHelper.SaveDSLRArUcoImage(dslrTexture, fileName);
CalibrationDataHelper.SaveHeadsetData(headsetData, fileName);
if (ProcessArUcoData(headsetData, dslrTexture))
{
CalibrationDataHelper.SaveDSLRArUcoDetectedImage(dslrTexture, fileName);
CreateVisual(headsetData, fileName);
}
}
headsetData = null;
}
if (Input.GetKeyDown(KeyCode.Return))
{
Debug.Log("Starting Individual Camera Extrinsics calculations.");
cameraExtrinsics = CalibrationAPI.Instance.CalculateIndividualArUcoExtrinsics(dslrIntrinsics, parentVisuals.Count);
if (cameraExtrinsics != null)
{
foreach (var extrinsic in cameraExtrinsics)
{
Debug.Log($"Calculated extrinsics: {extrinsic}");
}
CreateExtrinsicsVisual(cameraExtrinsics);
}
Debug.Log("Starting the Global Camera Extrinsics calculation.");
globalExtrinsics = CalibrationAPI.Instance.CalculateGlobalArUcoExtrinsics(dslrIntrinsics);
if (globalExtrinsics != null)
{
var fileName = CalibrationDataHelper.SaveCameraExtrinsics(globalExtrinsics);
Debug.Log($"Saved global extrinsics: {fileName}");
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";
}
}
}
