/// <summary>
        /// Creates the Stereo Cameras individually.
        /// Clipping planes are adjusted according to the set SceneScale
        /// </summary>
        /// <returns>The camera for each eye.</returns>
        /// <param name="name">Type Camera which needs to be created.</param>
        public GameObject CreateCameraforEachEye(CameraNames name)
        {
            Debug.Log("Creating " + name);

            GameObject go        = new GameObject(name.ToString(), typeof(Camera));
            Camera     eyecamera = go.GetComponent <Camera>();

            eyecamera.clearFlags      = CameraClearFlags.SolidColor;
            eyecamera.backgroundColor = new Color(0f, 0f, 0f, 0f);
            eyecamera.orthographic    = false;
            eyecamera.fieldOfView     = stereoCamFov;

            eyecamera.transform.localPosition = new Vector3(0, 0, 0f);
            eyecamera.depth         = 99;
            eyecamera.nearClipPlane = MiraArController.Instance.nearClipPlane * (1 / MiraArController.scaleMultiplier);
            eyecamera.farClipPlane  = MiraArController.Instance.farClipPlane * (1 / MiraArController.scaleMultiplier);

            eyecamera.allowHDR            = false;
            eyecamera.allowMSAA           = false;
            eyecamera.useOcclusionCulling = true;

            go.transform.SetParent(cameraRig.transform, false);
            // AsymmetricFrustum frust = go.AddComponent<AsymmetricFrustum>();

            RenderTexture EyeRenderTexture = new RenderTexture(1024, 1024, 0, RenderTextureFormat.ARGB32);

            EyeRenderTexture.useMipMap  = false;
            EyeRenderTexture.wrapMode   = TextureWrapMode.Clamp;
            EyeRenderTexture.filterMode = FilterMode.Bilinear;
            EyeRenderTexture.anisoLevel = 0;
            EyeRenderTexture.depth      = 24;

            EyeRenderTexture.Create();

            eyecamera.targetTexture = EyeRenderTexture;

            if (name == CameraNames.Left_Camera)
            {
                eyecamera.tag  = "MainCamera";
                eyecamera.rect = new Rect(0f, 0f, 1f, 1f);
                eyecamera.transform.localPosition = new Vector3(-MiraArController.Instance.IPD / 2 * 0.1f * (1 / MiraArController.scaleMultiplier), 0f, 0f);
                //eyecamera.transform.rotation = Quaternion.Euler(-90, 0, 0);
                MiraArController.Instance.leftCam = eyecamera.gameObject;
            }
            else
            {
                // frust.slideX = -asymmetricFrustrumSlide;
                eyecamera.rect = new Rect(0f, 0f, 1f, 1f);

                eyecamera.transform.localPosition = new Vector3(MiraArController.Instance.IPD / 2 * 0.1f * (1 / MiraArController.scaleMultiplier), 0f, 0f);
                //eyecamera.transform.rotation = Quaternion.Euler(-90, 0, 0);
                MiraArController.Instance.rightCam = eyecamera.gameObject;
            }
            return(go);
        }
Beispiel #2
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (CameraNames.Length != 0)
            {
                hash ^= CameraNames.GetHashCode();
            }
            if (InputCameraChannelNames.Length != 0)
            {
                hash ^= InputCameraChannelNames.GetHashCode();
            }
            if (TimestampOffset != 0D)
            {
                hash ^= TimestampOffset.GetHashCode();
            }
            if (CameraObstaclePerceptionConfDir.Length != 0)
            {
                hash ^= CameraObstaclePerceptionConfDir.GetHashCode();
            }
            if (CameraObstaclePerceptionConfFile.Length != 0)
            {
                hash ^= CameraObstaclePerceptionConfFile.GetHashCode();
            }
            if (FrameCapacity != 0)
            {
                hash ^= FrameCapacity.GetHashCode();
            }
            if (ImageChannelNum != 0)
            {
                hash ^= ImageChannelNum.GetHashCode();
            }
            if (EnableUndistortion != false)
            {
                hash ^= EnableUndistortion.GetHashCode();
            }
            if (EnableVisualization != false)
            {
                hash ^= EnableVisualization.GetHashCode();
            }
            if (OutputObstaclesChannelName.Length != 0)
            {
                hash ^= OutputObstaclesChannelName.GetHashCode();
            }
            if (CameraPerceptionVizMessageChannelName.Length != 0)
            {
                hash ^= CameraPerceptionVizMessageChannelName.GetHashCode();
            }
            if (PrefusedChannelName.Length != 0)
            {
                hash ^= PrefusedChannelName.GetHashCode();
            }
            if (DefaultCameraPitch != 0D)
            {
                hash ^= DefaultCameraPitch.GetHashCode();
            }
            if (DefaultCameraHeight != 0D)
            {
                hash ^= DefaultCameraHeight.GetHashCode();
            }
            if (LaneCalibrationWorkingSensorName.Length != 0)
            {
                hash ^= LaneCalibrationWorkingSensorName.GetHashCode();
            }
            if (CalibratorMethod.Length != 0)
            {
                hash ^= CalibratorMethod.GetHashCode();
            }
            if (CalibServiceName.Length != 0)
            {
                hash ^= CalibServiceName.GetHashCode();
            }
            if (RunCalibService != false)
            {
                hash ^= RunCalibService.GetHashCode();
            }
            if (OutputCameraDebugMsg != false)
            {
                hash ^= OutputCameraDebugMsg.GetHashCode();
            }
            if (CameraDebugChannelName.Length != 0)
            {
                hash ^= CameraDebugChannelName.GetHashCode();
            }
            if (TsDiff != 0D)
            {
                hash ^= TsDiff.GetHashCode();
            }
            if (OutputFinalObstacles != false)
            {
                hash ^= OutputFinalObstacles.GetHashCode();
            }
            return(hash);
        }
        public VideoConferenceViewModel(ISettingsUtils settingsUtils, ISettingsRepository <GeneralSettings> settingsRepository, Func <string, int> ipcMSGCallBackFunc, string configFileSubfolder = "")
        {
            if (settingsRepository == null)
            {
                throw new ArgumentNullException(nameof(settingsRepository));
            }

            GeneralSettingsConfig = settingsRepository.SettingsConfig;

            _settingsUtils = settingsUtils ?? throw new ArgumentNullException(nameof(settingsUtils));

            SendConfigMSG = ipcMSGCallBackFunc;

            _settingsConfigFileFolder = configFileSubfolder;

            try
            {
                Settings = _settingsUtils.GetSettings <VideoConferenceSettings>(GetSettingsSubPath());
            }
#pragma warning disable CA1031 // Do not catch general exception types
            catch
#pragma warning restore CA1031 // Do not catch general exception types
            {
                Settings = new VideoConferenceSettings();
                _settingsUtils.SaveSettings(Settings.ToJsonString(), GetSettingsSubPath());
            }

            CameraNames     = interop.CommonManaged.GetAllVideoCaptureDeviceNames();
            MicrophoneNames = interop.CommonManaged.GetAllActiveMicrophoneDeviceNames();
            MicrophoneNames.Insert(0, "[All]");

            var shouldSaveSettings = false;

            if (string.IsNullOrEmpty(Settings.Properties.SelectedCamera.Value) && CameraNames.Count != 0)
            {
                _selectedCameraIndex = 0;
                Settings.Properties.SelectedCamera.Value = CameraNames[0];
                shouldSaveSettings = true;
            }
            else
            {
                _selectedCameraIndex = CameraNames.FindIndex(name => name == Settings.Properties.SelectedCamera.Value);
            }

            if (string.IsNullOrEmpty(Settings.Properties.SelectedMicrophone.Value))
            {
                _selectedMicrophoneIndex = 0;
                Settings.Properties.SelectedMicrophone.Value = MicrophoneNames[0];
                shouldSaveSettings = true;
            }
            else
            {
                _selectedMicrophoneIndex = MicrophoneNames.FindIndex(name => name == Settings.Properties.SelectedMicrophone.Value);
            }

            _isEnabled = GeneralSettingsConfig.Enabled.VideoConference;
            _cameraAndMicrophoneMuteHotkey = Settings.Properties.MuteCameraAndMicrophoneHotkey.Value;
            _mirophoneMuteHotkey           = Settings.Properties.MuteMicrophoneHotkey.Value;
            _cameraMuteHotkey      = Settings.Properties.MuteCameraHotkey.Value;
            CameraImageOverlayPath = Settings.Properties.CameraOverlayImagePath.Value;
            SelectOverlayImage     = new ButtonClickCommand(SelectOverlayImageAction);
            ClearOverlayImage      = new ButtonClickCommand(ClearOverlayImageAction);

            _hideToolbarWhenUnmuted = Settings.Properties.HideToolbarWhenUnmuted.Value;

            switch (Settings.Properties.ToolbarPosition.Value)
            {
            case "Top left corner":
                _toolbarPositionIndex = 0;
                break;

            case "Top center":
                _toolbarPositionIndex = 1;
                break;

            case "Top right corner":
                _toolbarPositionIndex = 2;
                break;

            case "Bottom left corner":
                _toolbarPositionIndex = 3;
                break;

            case "Bottom center":
                _toolbarPositionIndex = 4;
                break;

            case "Bottom right corner":
                _toolbarPositionIndex = 5;
                break;
            }

            switch (Settings.Properties.ToolbarMonitor.Value)
            {
            case "Main monitor":
                _toolbarMonitorIndex = 0;
                break;

            case "All monitors":
                _toolbarMonitorIndex = 1;
                break;
            }

            if (shouldSaveSettings)
            {
                _settingsUtils.SaveSettings(Settings.ToJsonString(), ModuleName);
            }
        }
        public override int GetHashCode()
        {
            int hash = 1;

            if (TlTf2FrameId.Length != 0)
            {
                hash ^= TlTf2FrameId.GetHashCode();
            }
            if (TlTf2ChildFrameId.Length != 0)
            {
                hash ^= TlTf2ChildFrameId.GetHashCode();
            }
            if (Tf2TimeoutSecond != 0D)
            {
                hash ^= Tf2TimeoutSecond.GetHashCode();
            }
            if (CameraNames.Length != 0)
            {
                hash ^= CameraNames.GetHashCode();
            }
            if (CameraChannelNames.Length != 0)
            {
                hash ^= CameraChannelNames.GetHashCode();
            }
            if (TlImageTimestampOffset != 0D)
            {
                hash ^= TlImageTimestampOffset.GetHashCode();
            }
            if (MaxProcessImageFps != 0)
            {
                hash ^= MaxProcessImageFps.GetHashCode();
            }
            if (QueryTfIntervalSeconds != 0D)
            {
                hash ^= QueryTfIntervalSeconds.GetHashCode();
            }
            if (ValidHdmapInterval != 0D)
            {
                hash ^= ValidHdmapInterval.GetHashCode();
            }
            if (ImageSysTsDiffThreshold != 0D)
            {
                hash ^= ImageSysTsDiffThreshold.GetHashCode();
            }
            if (SyncIntervalSeconds != 0D)
            {
                hash ^= SyncIntervalSeconds.GetHashCode();
            }
            if (CameraTrafficLightPerceptionConfDir.Length != 0)
            {
                hash ^= CameraTrafficLightPerceptionConfDir.GetHashCode();
            }
            if (CameraTrafficLightPerceptionConfFile.Length != 0)
            {
                hash ^= CameraTrafficLightPerceptionConfFile.GetHashCode();
            }
            if (DefaultImageBorderSize != 0)
            {
                hash ^= DefaultImageBorderSize.GetHashCode();
            }
            if (TrafficLightOutputChannelName.Length != 0)
            {
                hash ^= TrafficLightOutputChannelName.GetHashCode();
            }
            if (SimulationChannelName.Length != 0)
            {
                hash ^= SimulationChannelName.GetHashCode();
            }
            if (V2XTrafficlightsInputChannelName.Length != 0)
            {
                hash ^= V2XTrafficlightsInputChannelName.GetHashCode();
            }
            if (V2XSyncIntervalSeconds != 0D)
            {
                hash ^= V2XSyncIntervalSeconds.GetHashCode();
            }
            if (MaxV2XMsgBuffSize != 0)
            {
                hash ^= MaxV2XMsgBuffSize.GetHashCode();
            }
            return(hash);
        }