ProfileManager::ProfileManager(bool sys_register) :
Changed(false)
{
// Attempt to get the base path automatically, but this may fail
BasePath = GetBaseOVRPath(false);
if (sys_register)
PushDestroyCallbacks();
}
String GyroTempCalibration::GetCalibrationPath(bool create_dir)
{
String path = GetBaseOVRPath(create_dir);
path += "/";
path += "GyroCalibration_";
path += DeviceSerialNumber;
path += ".json";
return path;
}
// Serializes the profiles to disk.
void ProfileManager::Save()
{
Lock::Locker lockScope(&ProfileLock);
if (ProfileCache == NULL)
return;
// Save the profile to disk
BasePath = GetBaseOVRPath(true); // create the base directory if it doesn't exist
String path = GetProfilePath();
ProfileCache->Save(path);
Changed = false;
}
// Loads a saved calibration for the specified device from the device profile file
// sensor - the sensor that the calibration was saved for
// cal_name - an optional name for the calibration or the default if cal_name == NULL
bool SensorFusion::LoadMagCalibration(const char* calibrationName)
{
if (CachedSensorInfo.SerialNumber[0] == 0)
return false;
// A named calibration may be specified for calibration in different
// environments, otherwise the default calibration is used
if (calibrationName == NULL)
calibrationName = "default";
String path = GetBaseOVRPath(true);
path += "/Devices.json";
// Load the device profiles
Ptr<JSON> root = *JSON::Load(path);
if (root == NULL)
return false;
// Quick sanity check of the file type and format before we parse it
JSON* version = root->GetFirstItem();
if (version && version->Name == "Oculus Device Profile Version")
{
int major = atoi(version->Value.ToCStr());
if (major > MAX_DEVICE_PROFILE_MAJOR_VERSION)
return false; // don't parse the file on unsupported major version number
}
else
{
return false;
}
bool autoEnableCorrection = false;
JSON* device = root->GetNextItem(version);
while (device)
{ // Search for a previous calibration with the same name for this device
// and remove it before adding the new one
if (device->Name == "Device")
{
JSON* item = device->GetItemByName("Serial");
if (item && item->Value == CachedSensorInfo.SerialNumber)
{ // found an entry for this device
JSON* autoyaw = device->GetItemByName("EnableYawCorrection");
if (autoyaw)
autoEnableCorrection = (autoyaw->dValue != 0);
int maxCalibrationVersion = 0;
item = device->GetNextItem(item);
while (item)
{
if (item->Name == "MagCalibration")
{
JSON* calibration = item;
JSON* name = calibration->GetItemByName("Name");
if (name && name->Value == calibrationName)
{ // found a calibration with this name
int major = 0;
JSON* version = calibration->GetItemByName("Version");
if (version)
major = atoi(version->Value.ToCStr());
if (major > maxCalibrationVersion && major <= 2)
{
time_t now;
time(&now);
// parse the calibration time
time_t calibration_time = now;
JSON* caltime = calibration->GetItemByName("Time");
if (caltime)
{
const char* caltime_str = caltime->Value.ToCStr();
tm ct;
memset(&ct, 0, sizeof(tm));
#if defined(OVR_OS_WIN32) and !defined(__MINGW32__)
struct tm nowtime;
localtime_s(&nowtime, &now);
ct.tm_isdst = nowtime.tm_isdst;
sscanf_s(caltime_str, "%d-%d-%d %d:%d:%d",
&ct.tm_year, &ct.tm_mon, &ct.tm_mday,
&ct.tm_hour, &ct.tm_min, &ct.tm_sec);
#else
struct tm* nowtime = localtime(&now);
ct.tm_isdst = nowtime->tm_isdst;
sscanf(caltime_str, "%d-%d-%d %d:%d:%d",
&ct.tm_year, &ct.tm_mon, &ct.tm_mday,
&ct.tm_hour, &ct.tm_min, &ct.tm_sec);
#endif
ct.tm_year -= 1900;
ct.tm_mon--;
calibration_time = mktime(&ct);
}
// parse the calibration matrix
JSON* cal = calibration->GetItemByName("CalibrationMatrix");
if (cal == NULL)
cal = calibration->GetItemByName("Calibration");
if (cal)
{
Matrix4f calmat = Matrix4f::FromString(cal->Value.ToCStr());
SetMagCalibration(calmat);
MagCalibrationTime = calibration_time;
EnableYawCorrection = autoEnableCorrection;
maxCalibrationVersion = major;
}
}
}
}
item = device->GetNextItem(item);
}
return (maxCalibrationVersion > 0);
}
}
device = root->GetNextItem(device);
}
return false;
}
// Writes the current calibration for a particular device to a device profile file
// sensor - the sensor that was calibrated
// cal_name - an optional name for the calibration or default if cal_name == NULL
bool SensorFusion::SaveMagCalibration(const char* calibrationName) const
{
if (CachedSensorInfo.SerialNumber[0] == 0 || !HasMagCalibration())
return false;
// A named calibration may be specified for calibration in different
// environments, otherwise the default calibration is used
if (calibrationName == NULL)
calibrationName = "default";
// Generate a mag calibration event
JSON* calibration = JSON::CreateObject();
// (hardcoded for now) the measurement and representation method
calibration->AddStringItem("Version", "2.0");
calibration->AddStringItem("Name", "default");
// time stamp the calibration
char time_str[64];
#if defined(OVR_OS_WIN32) and !defined(__MINGW32__)
struct tm caltime;
localtime_s(&caltime, &MagCalibrationTime);
strftime(time_str, 64, "%Y-%m-%d %H:%M:%S", &caltime);
#else
struct tm* caltime;
caltime = localtime(&MagCalibrationTime);
strftime(time_str, 64, "%Y-%m-%d %H:%M:%S", caltime);
#endif
calibration->AddStringItem("Time", time_str);
// write the full calibration matrix
char matrix[256];
Matrix4f calmat = GetMagCalibration();
calmat.ToString(matrix, 256);
calibration->AddStringItem("CalibrationMatrix", matrix);
// save just the offset, for backwards compatibility
// this can be removed when we don't want to support 0.2.4 anymore
Vector3f center(calmat.M[0][3], calmat.M[1][3], calmat.M[2][3]);
Matrix4f tmp = calmat; tmp.M[0][3] = tmp.M[1][3] = tmp.M[2][3] = 0; tmp.M[3][3] = 1;
center = tmp.Inverted().Transform(center);
Matrix4f oldcalmat; oldcalmat.M[0][3] = center.x; oldcalmat.M[1][3] = center.y; oldcalmat.M[2][3] = center.z;
oldcalmat.ToString(matrix, 256);
calibration->AddStringItem("Calibration", matrix);
String path = GetBaseOVRPath(true);
path += "/Devices.json";
// Look for a prexisting device file to edit
Ptr<JSON> root = *JSON::Load(path);
if (root)
{ // Quick sanity check of the file type and format before we parse it
JSON* version = root->GetFirstItem();
if (version && version->Name == "Oculus Device Profile Version")
{
int major = atoi(version->Value.ToCStr());
if (major > MAX_DEVICE_PROFILE_MAJOR_VERSION)
{
// don't use the file on unsupported major version number
root->Release();
root = NULL;
}
}
else
{
root->Release();
root = NULL;
}
}
JSON* device = NULL;
if (root)
{
device = root->GetFirstItem(); // skip the header
device = root->GetNextItem(device);
while (device)
{ // Search for a previous calibration with the same name for this device
// and remove it before adding the new one
if (device->Name == "Device")
{
JSON* item = device->GetItemByName("Serial");
if (item && item->Value == CachedSensorInfo.SerialNumber)
{ // found an entry for this device
item = device->GetNextItem(item);
while (item)
{
if (item->Name == "MagCalibration")
{
JSON* name = item->GetItemByName("Name");
if (name && name->Value == calibrationName)
{ // found a calibration of the same name
item->RemoveNode();
item->Release();
break;
}
}
item = device->GetNextItem(item);
}
// update the auto-mag flag
item = device->GetItemByName("EnableYawCorrection");
if (item)
item->dValue = (double)EnableYawCorrection;
else
device->AddBoolItem("EnableYawCorrection", EnableYawCorrection);
break;
}
}
device = root->GetNextItem(device);
}
}
else
{ // Create a new device root
root = *JSON::CreateObject();
root->AddStringItem("Oculus Device Profile Version", "1.0");
}
if (device == NULL)
{
device = JSON::CreateObject();
device->AddStringItem("Product", CachedSensorInfo.ProductName);
device->AddNumberItem("ProductID", CachedSensorInfo.ProductId);
device->AddStringItem("Serial", CachedSensorInfo.SerialNumber);
device->AddBoolItem("EnableYawCorrection", EnableYawCorrection);
root->AddItem("Device", device);
}
// Create and the add the new calibration event to the device
device->AddItem("MagCalibration", calibration);
return root->Save(path);
}
String GetProfilePath(bool create_dir)
{
String path = GetBaseOVRPath(create_dir);
path += "/Profiles.json";
return path;
}
