/// <summary>
/// Cycles to the next calibration type, if it reaches the end
/// start over.
/// </summary>
/// <returns>type of calibration :(pos, rot, vertex)</returns>
private CalibrationType CycleNextCalibrationType()
{
this.calibrationType = (from CalibrationType val in Enum.GetValues(typeof(CalibrationType)) where val > this.calibrationType orderby val select val).DefaultIfEmpty().First();
this.RpcSetCalibrationType(this.calibrationType);
this.infoDisplayInstance.SetText(this.calibrationType.ToString());
return(this.calibrationType);
}
public static bool Transformation2dTo3d(Calibration calibration, float[] sourcePoint2d, float sourceDepth,
CalibrationType sourceCamera, CalibrationType targetCamera, ref float[] targetPoint3d, ref int valid)
{
bool succeeded = false;
if (sourceCamera == CalibrationType.Depth)
{
succeeded = IntrinsicTransformation.Unproject(calibration.DepthCameraCalibration, sourcePoint2d, sourceDepth, ref targetPoint3d, ref valid);
}
else if (sourceCamera == CalibrationType.Color)
{
succeeded = IntrinsicTransformation.Unproject(calibration.ColorCameraCalibration, sourcePoint2d, sourceDepth, ref targetPoint3d, ref valid);
}
if (!succeeded)
{
return(false);
}
if (sourceCamera == targetCamera)
{
return(true);
}
else
{
return(Transformation3dTo3d(calibration, targetPoint3d, sourceCamera, targetCamera, ref targetPoint3d));;
}
}
public IActionResult ValidateName([FromBody] CalibrationType model)
{
if (model == null)
{
return(NotFound());
}
if (General.IsDevelopment)
{
logger.LogDebug(ModelState.ToJson());
}
var existing = repository.Get().FirstOrDefault(a => a.CalibrationTypeDesc == model.CalibrationTypeDesc);
if (existing == null)
{
return(Accepted(true));
}
if (existing.CalibrationTypeId != model.CalibrationTypeId)
{
return(UnprocessableEntity(Constants.ErrorMessages.EntityExists("Description")));
}
else
{
return(Accepted(true));
}
}
public static bool Transformation3dTo2d(Calibration calibration, float[] sourcePoint3d,
CalibrationType sourceCamera, CalibrationType targetCamera, ref float[] targetPoint2d, ref int valid)
{
float[] targetPoint3d = new float[3];
if (sourceCamera == targetCamera)
{
targetPoint3d[0] = sourcePoint3d[0];
targetPoint3d[1] = sourcePoint3d[1];
targetPoint3d[2] = sourcePoint3d[2];
}
else
{
bool succeeded = Transformation3dTo3d(calibration, sourcePoint3d, sourceCamera, targetCamera, ref targetPoint3d);
if (!succeeded)
{
return(false);
}
}
if (targetCamera == CalibrationType.Depth)
{
return(IntrinsicTransformation.Project(calibration.DepthCameraCalibration, targetPoint3d, ref targetPoint2d, ref valid));
}
else if (targetCamera == CalibrationType.Color)
{
return(IntrinsicTransformation.Project(calibration.ColorCameraCalibration, targetPoint3d, ref targetPoint2d, ref valid));
}
return(true);
}
public Calibrator(CalibrationType calType)
{
CalibType = calType;
FrequencyShift = 0;
LowMassFrequency = 0;
CalibConstA = CalibConstB = CalibConstC = 0;
IntensityNormalizer = 1;
}
public void CalibrationTypeOnAWGShouldBe(IAWG awg, CalibrationType expectedType)
{
string expectedSyntax = (expectedType == CalibrationType.External)
? CalibrationTypeExternalSyntax
: CalibrationTypeInternalSyntax;
const string possibleErrorMessage = "Checking the copy for the calibration type.";
Assert.AreEqual(expectedSyntax, awg.CalibrationType, possibleErrorMessage);
}
public static bool InitXyTables(Calibration calibration, CalibrationType camera, out float[] xyTables)
{
int width = 0;
int height = 0;
switch (camera)
{
case CalibrationType.Depth:
width = calibration.DepthCameraCalibration.resolutionWidth;
height = calibration.DepthCameraCalibration.resolutionHeight;
break;
case CalibrationType.Color:
width = calibration.ColorCameraCalibration.resolutionWidth;
height = calibration.ColorCameraCalibration.resolutionHeight;
break;
default:
xyTables = null;
return(false);
}
xyTables = new float[2 * width * height];
float[] point2d = new float[2];
float[] point3d = new float[3];
int valid = 0;
for (int y = 0, idx = 0; y < height; y++)
{
point2d[1] = (float)y;
for (int x = 0; x < width; x++, idx++)
{
point2d[0] = (float)x;
bool succeeded = Transformation2dTo3d(calibration, point2d, 1.0f, camera, camera, ref point3d, ref valid);
if (!succeeded)
{
return(false);
}
if (valid == 0)
{
xyTables[2 * idx] = 0.0f;
xyTables[2 * idx + 1] = 0.0f;
}
else
{
xyTables[2 * idx] = point3d[0];
xyTables[2 * idx + 1] = point3d[1];
}
}
}
return(true);
}
public bool ValidateName(CalibrationType model)
{
var existing = Get().FirstOrDefault(a => a.CalibrationTypeDesc == model.CalibrationTypeDesc);
if (existing == null)
{
return(true);
}
return(existing.CalibrationTypeId == model.CalibrationTypeId);
}
private bool validateEntity(CalibrationType model)
{
var validName = repository.ValidateName(model);
if (!validName)
{
ModelState.AddModelError(nameof(CalibrationType.CalibrationTypeDesc), Constants.ErrorMessages.EntityExists("Name"));
}
return(ModelState.ErrorCount == 0);
}
public void ResetCalibration()
{
CurrentCalibrationType = CalibrationType.RELATIVE;
Calibration(CalibrationAxis.X, -RelativeAngle.x);
Calibration(CalibrationAxis.Y, -RelativeAngle.y);
Calibration(CalibrationAxis.Z, -RelativeAngle.z);
CurrentCalibrationType = CalibrationType.ABSOLUTE;
Calibration(CalibrationAxis.X, -AbsoluteAngle.x);
Calibration(CalibrationAxis.Y, -AbsoluteAngle.y);
Calibration(CalibrationAxis.Z, -AbsoluteAngle.z);
}
public clsRawDataPreprocessOptions()
{
menmApodizationType = ApodizationType.NOAPODIZATION;
mintApodizationPercent = 50;
mdbl_apodization_min_x = 0;
mdbl_apodization_max_x = 0.9437166;
mshort_num_zeros = 0;
menmCalibrationType = CalibrationType.UNDEFINED;
mdbl_A = 0;
mdbl_B = 0;
mdbl_C = 0;
}
public IActionResult Get([FromQuery] CalibrationType parameters = null)
{
try
{
var model = repository.Get(parameters);
return(Ok(model));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.FetchError));
}
}
public CalibrationType Update(CalibrationType model)
{
var entity = dbContext.CalibrationTypes.Find(model.CalibrationTypeId);
if (entity == null)
{
throw new Exception("Selected Record does not exists.");
}
entity.CalibrationTypeDesc = (model.CalibrationTypeDesc ?? "").ToUpper();
entity.IsActive = model.IsActive;
dbContext.CalibrationTypes.Update(entity);
dbContext.SaveChanges();
return(entity);
}
// once this calibration function is called, the default calibration is
// overridden.
public virtual void OverrideDefaultCalibrator(CalibrationType calibType, double A, double B, double C)
{
mbln_use_specified_calibration = true;
menm_calibration_type = calibType;
var calib = new Calibrations.Calibrator(menm_calibration_type);
calib.NumPointsInScan = mint_num_points_in_scan;
calib.LowMassFrequency = mdbl_low_mass_freq;
calib.SampleRate = mdbl_sample_rate;
mdbl_calib_const_a = A;
mdbl_calib_const_b = B;
mdbl_calib_const_c = C;
calib.SetCalibrationEquationParams(mdbl_calib_const_a, mdbl_calib_const_b, mdbl_calib_const_c);
SetCalibrator(calib);
}
private void bntStart_Click(object sender, EventArgs e)
{
bntStart.Enabled = false;
CharacteristoOfTransformationParametrs param = ReadDataFromFields();
CalibrationType selectedTypesOfClaibration = (CalibrationType)Enum.Parse(typeof(CalibrationType), cmdMethodOfCalibration.SelectedValue.ToString());
if (param != null)
{
graphArrays = ADCCharacteristicHelper.GetDiagramOfTransformation(unit, param, selectedTypesOfClaibration, out regTrackWithoutCalibration, out regTrackWithCalibration);
DrawGraph();
}
bntStart.Enabled = true;
}
public void SetCalibrationMode(bool active, CalibrationType calibrationType = CalibrationType.ABSOLUTE)
{
if (ViveSR_DualCameraRig.Instance.TrackedCameraLeft == null || ViveSR_DualCameraRig.Instance.TrackedCameraRight == null)
{
return;
}
CurrentCalibrationType = calibrationType;
IsCalibrating = active;
if (IsCalibrating)
{
ViveSR_DualCameraRig.Instance.TrackedCameraRight.ImagePlaneCalibration.gameObject.SetActive(calibrationType == CalibrationType.RELATIVE);
}
else
{
ViveSR_DualCameraRig.Instance.TrackedCameraRight.ImagePlaneCalibration.gameObject.SetActive(false);
}
}
public CalibratorApplication(IEnumerable <MeasureResultBase> results, CalibrationConstants constants)
{
_results = results;
_constants = constants;
if (results is IEnumerable <InclinometrTemperatureCalibrator.MeasureResult> )
{
_calibrationType = CalibrationType.TEMPERATURE;
}
else if (results is IEnumerable <InclinometrAngularCalibrator.MeasureResult> )
{
_calibrationType = CalibrationType.ANGULAR;
}
else
{
throw new NotSupportedException();
}
}
public IActionResult Post([FromBody] CalibrationType model)
{
try
{
if (!ModelState.IsValid)
{
return(InvalidModelStateResult());
}
if (!validateEntity(model))
{
return(InvalidModelStateResult());
}
return(Accepted(repository.Create(model)));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.CreateError));
}
}
public static bool Transformation3dTo3d(Calibration calibration, float[] sourcePoint3d,
CalibrationType sourceCamera, CalibrationType targetCamera, ref float[] targetPoint3d)
{
if (sourceCamera == targetCamera)
{
targetPoint3d[0] = sourcePoint3d[0];
targetPoint3d[1] = sourcePoint3d[1];
targetPoint3d[2] = sourcePoint3d[2];
return(true);
}
bool succeeded = ExtrinsicTransformation.ApplyExtrinsicTransformation(calibration.SourceToTargetExtrinsics, sourcePoint3d, ref targetPoint3d);
if (!succeeded)
{
return(false);
}
return(true);
}
private void buttonStart_Click(object sender, EventArgs e)
{
paneCode.CurveList.Clear();
paneCode.GraphObjList.Clear();
//StrategyEnums selectedTypesOfStrategy = (StrategyEnums)Enum.Parse(typeof(StrategyEnums), cmbxStrategyType.SelectedValue.ToString());
CalibrationType selectedTypesOfClaibration = (CalibrationType)Enum.Parse(typeof(CalibrationType), cmbxStrategyType.SelectedValue.ToString());
var dic1 = new Dictionary <int, double>();
var dic2 = new Dictionary <int, double>();
graphArrays = ADCCharacteristicHelper.GetDiagramOfTransformationGKS(unit, new CharacteristoOfTransformationParametrs(int.MaxValue, 0,
new Utils.SignalGenerator.AnalogSignal(Utils.SignalGenerator.TypesOfSignalEnum.KxB, new LineParametrs(0, 0))), selectedTypesOfClaibration, out dic1, out dic2);
DrawWithOutCalibrations();
DrawWithCalibrations();
zedGraphControl3.AxisChange();
zedGraphControl3.Invalidate();
}
public void SetCalibration(SensorTypeEnum sensorType, CalibrationType calibrationType)
{
if (!isInitialized)
{
return;
}
var calibrationCommand = String.Empty;
switch (calibrationType)
{
case CalibrationType.Mid:
calibrationCommand = midCalibrationCommand;
break;
case CalibrationType.Low:
calibrationCommand = lowCalibrationCommand;
break;
case CalibrationType.High:
calibrationCommand = highCalibrationCommand;
break;
default:
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
string strResult = String.Empty;
var taskCal = Task.Run(async() => {
await WriteAsync(calibrationCommand, currentSensor);
});
taskCal.Wait();
}
}
public void SetCalibration(SensorTypeEnum sensorType, CalibrationType calibrationType)
{
if (!isInitialized)
{
return;
}
var calibrationCommand = String.Empty;
switch (calibrationType)
{
case CalibrationType.Mid:
calibrationCommand = midCalibrationCommand;
break;
case CalibrationType.Low:
calibrationCommand = lowCalibrationCommand;
break;
case CalibrationType.High:
calibrationCommand = highCalibrationCommand;
break;
default:
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
var tsk = Task.Run(async() =>
{
await SendCommand(currentSensor.currentSerialPort, calibrationCommand);
});
tsk.Wait();
}
}
public void CalibrationsOfADC(CalibrationType typeOfCalibration)
{
if (adcInst.reg is SCHVNRegister)
{
switch (typeOfCalibration)
{
case CalibrationType.Tracking:
CalibrateAdcWeights(StrategyEnums.Tracking);
this.adcInst.dac.isCalibrated = false;
CalibrateAdcTrack();
return;
case CalibrationType.Cletching:
CalibrateAdcWeights(StrategyEnums.Tracking);
this.adcInst.dac.isCalibrated = false;
CalibrateAdcCletch();
return;
default:
return;
}
}
}
public IActionResult Put([FromBody] CalibrationType model)
{
try
{
if (!ModelState.IsValid)
{
return(InvalidModelStateResult());
}
if (!validateEntity(model))
{
return(InvalidModelStateResult());
}
if (repository.Get().Count(a => a.CalibrationTypeId.Equals(model.CalibrationTypeId)) == 0)
{
return(NotFound(Constants.ErrorMessages.NotFoundEntity));
}
return(Accepted(repository.Update(model)));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.UpdateError));
}
}
private void ExtractSettings(int start_p, string option_str)
{
short short_bluff;
double sample_rate;
double anal_trap_voltage;
double conductance_lim_voltage, source_trap_voltage;
short calibration_type;
double low_mass_frequency;
int temp_int;
Helpers.GetInt32(option_str, "dataPoints:", start_p, out temp_int);
mint_num_points_in_scan = temp_int;
Helpers.GetDouble(option_str, "dwell:", start_p, out sample_rate);
if (sample_rate != 0)
{
sample_rate = 1 / sample_rate;
}
if (Helpers.GetInt16(option_str, "Zerofill=true", start_p, out short_bluff))
{
mbln_zero_fill = true;
}
short temp;
Helpers.GetInt16(option_str, "ZerofillNumber=", start_p, out temp);
mshort_num_zero_fill = temp;
Helpers.GetDouble(option_str, "analyzerTrapVoltage:", start_p, out anal_trap_voltage);
Helpers.GetDouble(option_str, "conductanceLimitVoltage:", start_p, out conductance_lim_voltage);
Helpers.GetDouble(option_str, "sourceTrapVoltage:", start_p, out source_trap_voltage);
Helpers.GetInt16(option_str, "calType:", start_p, out calibration_type);
Helpers.GetDouble(option_str, "calReferenceFrequency:", start_p, out low_mass_frequency);
double calib_a = 0;
bool found_a;
found_a = Helpers.GetDouble(option_str, "calC0:", start_p, out calib_a);
double calib_b = 0;
bool found_b;
found_b = Helpers.GetDouble(option_str, "calC1:", start_p, out calib_b);
double calib_c = 0;
bool found_c;
found_c = Helpers.GetDouble(option_str, "calC2:", start_p, out calib_c);
Helpers.GetDouble(option_str, "chirpStartFrequency:", start_p, out low_mass_frequency);
if (Helpers.GetInt16(option_str, "detectType:analyzer", start_p, out short_bluff))
{
calib_b = calib_b * Math.Abs(anal_trap_voltage);
}
else
{
calib_b = calib_b * Math.Abs(source_trap_voltage);
}
if (calibration_type == 2)
{
// Call ErrorMess.LogError("Warning, type 2 calibration, make sure intensity option is defined in calibration generation dialog!", ps.FileName)
calib_c = calib_c * Math.Abs(anal_trap_voltage);
}
if (calib_a == 0 && calib_b == 0 && calib_c == 0)
{
//no header cal data found, use defaults!
//Call ErrorMess.LogError("No calibration data in file, using defaults...", ps.FileName)
calib_a = 108205311.2284;
calib_b = -1767155067.018;
calib_c = 29669467490280;
}
menm_calibration_type = (CalibrationType)calibration_type;
var calib = new Calibrations.Calibrator(menm_calibration_type);
calib.NumPointsInScan = this.mint_num_points_in_scan;
calib.LowMassFrequency = low_mass_frequency;
calib.SampleRate = sample_rate;
calib.SetCalibrationEquationParams(calib_a, calib_b, calib_c);
SetCalibrator(calib);
}
/// <summary>
/// Load calibration module.
/// </summary>
public static void Calibrate(CalibrationType type)
{
calibrationType = type;
LoadStep(0);
}
private void ManualCalibration(CalibrationType CalibrationType, int Value)
{
if (chkPCBACalibrationCalibrationEnable.Checked == false)
{
Notify.PopUpError("Calibration Disabled", "Command not executed because the 'Calibration Enable' check box is not checked.");
return;
}
int HGAIndex = 0;
if (rdxPCBACalibrationManualCalibrationHGA1.Checked)
{
HGAIndex = 1;
}
else if (rdxPCBACalibrationManualCalibrationHGA2.Checked)
{
HGAIndex = 2;
}
else if (rdxPCBACalibrationManualCalibrationHGA3.Checked)
{
HGAIndex = 3;
}
else if (rdxPCBACalibrationManualCalibrationHGA4.Checked)
{
HGAIndex = 4;
}
else if (rdxPCBACalibrationManualCalibrationHGA5.Checked)
{
HGAIndex = 5;
}
else if (rdxPCBACalibrationManualCalibrationHGA6.Checked)
{
HGAIndex = 6;
}
else if (rdxPCBACalibrationManualCalibrationHGA7.Checked)
{
HGAIndex = 7;
}
else if (rdxPCBACalibrationManualCalibrationHGA8.Checked)
{
HGAIndex = 8;
}
else if (rdxPCBACalibrationManualCalibrationHGA9.Checked)
{
HGAIndex = 9;
}
else if (rdxPCBACalibrationManualCalibrationHGA10.Checked)
{
HGAIndex = 10;
}
int ChannelNumber = 0;
if (rdxPCBACalibrationManualCalibrationCh1.Checked)
{
ChannelNumber = 1;
}
else if (rdxPCBACalibrationManualCalibrationCh2.Checked)
{
ChannelNumber = 2;
}
else if (rdxPCBACalibrationManualCalibrationCh3.Checked)
{
ChannelNumber = 3;
}
else if (rdxPCBACalibrationManualCalibrationCh4.Checked)
{
ChannelNumber = 4;
}
else if (rdxPCBACalibrationManualCalibrationCh5.Checked)
{
ChannelNumber = 5;
}
else if (rdxPCBACalibrationManualCalibrationCh6.Checked)
{
ChannelNumber = 6;
}
int ResistanceValue = 0;
int CapacitanceValue = 0;
byte[] ByteArrayValue;
if (CalibrationType == CalibrationType.ResistanceCalibration)
{
ResistanceValue = Value * 1000; // Change from Ohm to milliOhm
ByteArrayValue = BitConverter.GetBytes(ResistanceValue);
}
else
{
CapacitanceValue = Value;
ByteArrayValue = BitConverter.GetBytes(CapacitanceValue);
}
disableAllAPIButtons();
//TestProbe21SetManualCalibration
TestProbe21SetManualCalibration.CalibrationType = Convert.ToByte(CalibrationType);
TestProbe21SetManualCalibration.HGAIndex = Convert.ToByte(HGAIndex);
TestProbe21SetManualCalibration.ChannelNumber = Convert.ToByte(ChannelNumber);
TestProbe21SetManualCalibration.ExternalValueLSBLow = ByteArrayValue[0];
TestProbe21SetManualCalibration.ExternalValueLSBMid = ByteArrayValue[1];
TestProbe21SetManualCalibration.ExternalValueMSBLow = ByteArrayValue[2];
TestProbe21SetManualCalibration.ExternalValueMSBHigh = ByteArrayValue[3];
byte[] ByteArrayFromStructure = CommonFunctions.Instance.StructureToByteArray(TestProbe21SetManualCalibration);
TestProbeAPICommand APICommand = new TestProbeAPICommand(TestProbeAPICommand.HST_manual_set_calibration_Message_ID, TestProbeAPICommand.HST_manual_set_calibration_Message_Size, ByteArrayFromStructure);
CommonFunctions.Instance.OutgoingTestProbeDataAPIs.Enqueue(APICommand);
bool commandSentToMicroprocessor = constructAndSendWriteDataBuffer();
enableAllAPIButtons();
if (commandSentToMicroprocessor)
{
IsPCBACalibrationTempered = true;
tabPagePCBACalibration.Refresh();
}
}
void RpcSetCalibrationType(CalibrationType calibrationType)
{
this.calibrationType = calibrationType;
this.infoDisplayInstance.SetText(calibrationType.ToString());
}
/// <summary>
/// Load the custom calibration parameters from DualCameraParameters.xml.
/// </summary>
public void LoadDeviceParameter()
{
foreach (DualCameraIndex camIndex in Enum.GetValues(typeof(DualCameraIndex)))
{
ViveSR_TrackedCamera trackedCamera = camIndex == DualCameraIndex.LEFT ? ViveSR_DualCameraRig.Instance.TrackedCameraLeft :
ViveSR_DualCameraRig.Instance.TrackedCameraRight;
if (trackedCamera != null)
{
int camValue = camIndex == DualCameraIndex.LEFT ? 0 : 1;
trackedCamera.Anchor.transform.localPosition = new Vector3(0,
-ViveSR_DualCameraImageCapture.OffsetHeadToCamera[camValue * 3 + 1],
-ViveSR_DualCameraImageCapture.OffsetHeadToCamera[camValue * 3 + 2]);
for (int planeIndex = 0; planeIndex < 2; planeIndex++)
{
ViveSR_DualCameraImagePlane imagePlane = planeIndex == 0 ? trackedCamera.ImagePlane :
trackedCamera.ImagePlaneCalibration;
if (imagePlane != null)
{
imagePlane.DistortedImageWidth = ViveSR_DualCameraImageCapture.DistortedImageWidth;
imagePlane.DistortedImageHeight = ViveSR_DualCameraImageCapture.DistortedImageHeight;
imagePlane.UndistortedImageWidth = ViveSR_DualCameraImageCapture.UndistortedImageWidth;
imagePlane.UndistortedImageHeight = ViveSR_DualCameraImageCapture.UndistortedImageHeight;
if (camIndex == DualCameraIndex.LEFT)
{
imagePlane.DistortedCx = ViveSR_DualCameraImageCapture.DistortedCx_L;
imagePlane.DistortedCy = ViveSR_DualCameraImageCapture.DistortedCy_L;
imagePlane.UndistortedCx = ViveSR_DualCameraImageCapture.UndistortedCx_L;
imagePlane.UndistortedCy = ViveSR_DualCameraImageCapture.UndistortedCy_L;
imagePlane.FocalLength = ViveSR_DualCameraImageCapture.FocalLength_L;
imagePlane.UndistortionMap = ViveSR_DualCameraImageCapture.UndistortionMap_L;
}
else if (camIndex == DualCameraIndex.RIGHT)
{
imagePlane.DistortedCx = ViveSR_DualCameraImageCapture.DistortedCx_R;
imagePlane.DistortedCy = ViveSR_DualCameraImageCapture.DistortedCy_R;
imagePlane.UndistortedCx = ViveSR_DualCameraImageCapture.UndistortedCx_R;
imagePlane.UndistortedCy = ViveSR_DualCameraImageCapture.UndistortedCy_R;
imagePlane.FocalLength = ViveSR_DualCameraImageCapture.FocalLength_R;
imagePlane.UndistortionMap = ViveSR_DualCameraImageCapture.UndistortionMap_R;
}
}
}
}
}
ViveSR_DualCameraRig.Instance.HMDCameraShifter.CameraShiftZ = ViveSR_DualCameraImageCapture.OffsetHeadToCamera[2];
Vector3 relativeAngle = new Vector3(float.Parse((string)Registry.GetValue(rootPaht, keyNameRelativeAngle + "_x", 0)),
float.Parse((string)Registry.GetValue(rootPaht, keyNameRelativeAngle + "_y", 0)),
float.Parse((string)Registry.GetValue(rootPaht, keyNameRelativeAngle + "_z", 0)));
Vector3 absoluteAngle = new Vector3(float.Parse((string)Registry.GetValue(rootPaht, keyNameAbsoluteAngle + "_x", 0)),
float.Parse((string)Registry.GetValue(rootPaht, keyNameAbsoluteAngle + "_y", 0)),
float.Parse((string)Registry.GetValue(rootPaht, keyNameAbsoluteAngle + "_z", 0)));
CurrentCalibrationType = CalibrationType.RELATIVE;
Calibration(CalibrationAxis.X, relativeAngle.x);
Calibration(CalibrationAxis.Y, relativeAngle.y);
Calibration(CalibrationAxis.Z, relativeAngle.z);
CurrentCalibrationType = CalibrationType.ABSOLUTE;
Calibration(CalibrationAxis.X, absoluteAngle.x);
Calibration(CalibrationAxis.Y, absoluteAngle.y);
Calibration(CalibrationAxis.Z, absoluteAngle.z);
}
/// <summary>
/// Sets an awg to a cal type
/// </summary>
/// <param name="awg">the AWG object</param>
/// <param name="calType"></param>
public void SetTheCalibrationTypeToType(IAWG awg, CalibrationType calType)
{
string calTypeSyntax = (calType == CalibrationType.External) ? CalibrationTypeExternalSyntax : CalibrationTypeInternalSyntax;
awg.CalType(calTypeSyntax);
}
