コード例 #1
0
        private ComputeDeviceState QueryDeviceState(ComputeDeviceInfo currentDeviceInfo, int port)
        {
            bool validPort = currentDeviceInfo.PortList.Any(p => p == port);

            if (!validPort)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("[ERROR] QueryDeviceState(devId={0}, port={1}) Port does not exists", currentDeviceInfo.ComputeDeviceId, port);
                Console.ResetColor();
                return(null);
            }

            if (computeDeviceStateMap.ContainsKey(currentDeviceInfo))
            {
                if (computeDeviceStateMap[currentDeviceInfo].ContainsKey(port))
                {
                    return(computeDeviceStateMap[currentDeviceInfo][port]);
                }
                else
                {
                    return(computeDeviceStateMap[currentDeviceInfo][port] = new ComputeDeviceState());
                }
            }

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("[ERROR] QueryDeviceState(devId={0}, port={1}) Unable to fetch data", currentDeviceInfo.ComputeDeviceId, port);
            Console.ResetColor();
            return(null);
        }
コード例 #2
0
        public string _GetShortFormattedComputeDeviceState(ComputeDeviceState state)
        {
            string result = "(";

            foreach (var algo in state.AssignedAlgorithmDescriptionMap)
            {
                if (algo.Value)
                {
                    result += "Algo=" + algo.Key.AlgorithmTypeId + "," + algo.Key.Name + ";";
                }
            }

            foreach (var preset in state.AssignedPresetDescriptionMap)
            {
                if (preset.Value)
                {
                    result += "PresetId&Name=" + preset.Key.Id + "," + preset.Key.Name + ";";
                }
            }

            foreach (var camera in state.OpenCameraMap)
            {
                if (camera.Value)
                {
                    result += "Camera=" + camera.Key.Id + "," + camera.Key.Label + ";";
                }
            }


            result += ")";
            return(result);
        }
コード例 #3
0
        // Private ExecutePresetHelper
        private string ExecutePresetHelper(string presetId, CameraConfiguration cameraConfiguration, string postScript)
        {
            int  RunCompatibility      = 0;
            bool targetCameraOpen      = false;
            bool targetAlgorithmActive = false;

            PresetDescription presetConfiguration = utility.QueryPresetById(presetId, brokerHubHost, brokerHubPort);

            if (presetConfiguration == null)
            {
                throw new Exception("Preset not found: " + presetId);
            }

            ComputeDeviceInfo computeDevice = utility.QueryComputeDeviceById(presetConfiguration.ComputeDeviceId);
            int port = presetConfiguration.Port;

            ComputeDeviceState currentState = QueryDeviceState(computeDevice, port);

            logger.LogComputeDeviceStateMap(computeDeviceStateMap, string.Format("QueryDeviceState({0}, {1}) = {2}", computeDevice.ComputeDeviceId, port.ToString(), logger._GetShortFormattedComputeDeviceState(currentState)));

            if (currentState == null)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("[ERROR] ExecutePreset(presetId={0}, cameraId={1}) Failure in current state", presetId, cameraConfiguration.Id);
                Console.ResetColor();
                return(null);
            }

            // Any logic for deciding on run
            // Update statusMap with conditions
            if (!(currentState.IsAnyAlgorithmsActive() || currentState.IsAnyCameraActive() || currentState.IsAnyPresetActive()))
            {
                RunCompatibility = 1;
            }
            // If same algorithm, camera is there but preset is over, then run
            else if (currentState.IsAlgorithmActive(presetConfiguration.AlgorithmId) && currentState.IsCameraActive(cameraConfiguration.Id) && !(currentState.IsPresetActive(presetId)))
            {
                RunCompatibility = 2;
            }
            else
            {
                RunCompatibility = 5;

                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("[FIX NEEDED] ExecutePreset(presetId={0}, cameraId={1}) Backdoor activated for allowing execution", presetId, cameraConfiguration.Id);
                Console.ResetColor();
            }

            if (currentState.IsCameraActive(cameraConfiguration.Id))
            {
                targetCameraOpen = true;
            }
            if (currentState.IsAlgorithmActive(presetConfiguration.AlgorithmId))
            {
                targetAlgorithmActive = true;
            }


            // If run compatibility satisfies, run the algorithm in specific compute device
            if (RunCompatibility > 0)
            {
                string result = "";

                // If camera already not loaded, call LoadCamera
                if (!targetCameraOpen)
                {
                    result = utility.LoadCamera(cameraConfiguration.Id, computeDevice, port);
                    if (result == null)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("[ERROR] ExecutePreset(presetId={0}, cameraId={1}) LoadCamera() Failed", presetId, cameraConfiguration.Id);
                        Console.ResetColor();
                        return(null);
                    }
                    else
                    {
                        computeDeviceStateMap[computeDevice][port].SetCameraActive(cameraConfiguration);
                        logger.LogComputeDeviceStateMap(computeDeviceStateMap, string.Format("SetCameraActive={0}", cameraConfiguration.Id + "," + cameraConfiguration.Label));
                    }
                }


                // If preset request to run ScalarExecuteCommand attribute, call the InitCommandFirst
                if (!targetAlgorithmActive)
                {
                    result = utility.ExecuteAlgorithm(presetConfiguration, computeDevice.IpAddress, "InitCommand");

                    if (result == null)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("[ERROR] ExecutePreset(presetId={0}, cameraId={1}) InitAlgo Failed", presetId, cameraConfiguration.Id);
                        Console.ResetColor();
                        return(null);
                    }
                }

                computeDeviceStateMap[computeDevice][port].SetPresetActive(presetConfiguration, utility.GetAlgorithmsList());
                presetCameraMap[presetId] = cameraConfiguration;
                logger.LogComputeDeviceStateMap(computeDeviceStateMap, "SetPresetActive=" + presetConfiguration.Id + "," + presetConfiguration.Name);

                // If preset is one time run, then clear preset from the statusMap
                if (presetConfiguration.ReturnResult && !presetConfiguration.InfiniteLoop && (presetConfiguration.RunOnce || presetConfiguration.LoopLimit == 1))
                {
                    computeDeviceStateMap[computeDevice][port].ClearPreset(presetConfiguration.Id);
                    logger.LogComputeDeviceStateMap(computeDeviceStateMap, "One Run ClearPreset=" + presetConfiguration.Id + "," + presetConfiguration.Name);
                }


                if (postScript == null)
                {
                    result = utility.ExecuteAlgorithm(presetConfiguration, computeDevice.IpAddress);
                }
                else
                {
                    result = utility.ExecuteAlgorithm(presetConfiguration, computeDevice.IpAddress, resultStatementToOverride: postScript);
                }


                if (result == null)
                {
                    computeDeviceStateMap[computeDevice][port].ClearPreset(presetConfiguration.Id);
                    logger.LogComputeDeviceStateMap(computeDeviceStateMap, "Preset Failure ClearPreset=" + presetConfiguration.Id + "," + presetConfiguration.Name);


                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("[ERROR] ExecutePreset(presetId={0}, cameraId={1}) Preset Execution Failed", presetId, cameraConfiguration.Id);
                    Console.ResetColor();

                    return(null);
                }

                return(result);
            }

            return(null);
        }