public void StartVideo(bool isContinue = true) { try { if (managedCamera != null && _videoMode == false) { if (isContinue) { // Set acquisition mode to continuous IEnum iAcquisitionMode = nodeMap.GetNode <IEnum>("AcquisitionMode"); IEnumEntry iAcquisitionModeContinuous = iAcquisitionMode.GetEntryByName("Continuous"); iAcquisitionMode.Value = iAcquisitionModeContinuous.Symbolic; } // Configure image events imageEventListener = new ImageEventListener(imageQueue); managedCamera.RegisterEvent(imageEventListener); // Begin acquiring images managedCamera.BeginAcquisition(); _videoMode = true; } } catch (SpinnakerException ex) { Debug.WriteLine("Error: {0}", ex.Message); } }
public bool SetStreamBufferCount(long count) { try { // set to manual INodeMap sNodeMap = managedCamera.GetTLStreamNodeMap(); IEnum sBufferCountSelector = sNodeMap.GetNode <IEnum>("StreamBufferCountMode"); if (sBufferCountSelector == null || !sBufferCountSelector.IsWritable) { return(false); } IEnumEntry iBufferCountManual = sBufferCountSelector.GetEntryByName("Manual"); if (iBufferCountManual == null || !iBufferCountManual.IsReadable) { return(false); } sBufferCountSelector.Value = iBufferCountManual.Symbolic; // set the value IInteger streamNode = sNodeMap.GetNode <IInteger>("StreamDefaultBufferCount"); if (streamNode == null || !streamNode.IsWritable) { return(false); } streamNode.Value = count; } catch { return(false); } return(true); }
private bool AppendEnumValue([NotNull] ConstantValue constantValue, [NotNull] IEnum enumType) { IList <IField> fields = CSharpEnumUtil.CalculateEnumMembers(constantValue, enumType); if (fields.Count == 0) { return(false); } string typeHighlighterId = _useReSharperColors ? HighlightingAttributeIds.TYPE_ENUM_ATTRIBUTE : VsHighlightingAttributeIds.Enums; string valueHighlighterId = _useReSharperColors ? HighlightingAttributeIds.CONSTANT_IDENTIFIER_ATTRIBUTE : VsHighlightingAttributeIds.Identifier; var orderedFields = fields.OrderBy(f => f.ShortName); bool addSeparator = false; foreach (IField orderedField in orderedFields) { if (addSeparator) { AppendText(" | ", VsHighlightingAttributeIds.Operator); } AppendText(enumType.ShortName, typeHighlighterId); AppendText(".", VsHighlightingAttributeIds.Operator); AppendText(orderedField.ShortName, valueHighlighterId); addSeparator = true; } return(true); }
public static IEnumVal AddValue(this IEnum enm, string name) { var enmVal = Noast.Create <IEnumVal>(name); enm.Values.Add(enmVal); return(enmVal); }
/// <summary> /// OldestFirst = 0, /// OldestFirstOverwrite = 1, /// NewestFirst = 2, /// NewestFirstOverwrite = 3, /// NUMSTREAMBUFFERHANDLINGMODE = 4 /// </summary> /// <param name="strMode"></param> public override bool SetStreamBufferHandlingMode(string strMode) { bool ret = false; try { INodeMap sNodeMap = m_Camera.GetTLStreamNodeMap(); IEnum iStreamBufferHandlingMode = sNodeMap.GetNode <IEnum>("StreamBufferHandlingMode"); if (iStreamBufferHandlingMode == null || !iStreamBufferHandlingMode.IsWritable) { return(false); } IEnumEntry iMode = iStreamBufferHandlingMode.GetEntryByName(strMode); if (iMode == null || !iMode.IsReadable) { return(false); } iStreamBufferHandlingMode.Value = iMode.Symbolic; ret = true; } catch (Exception ex) { LogHelper.AppLoger.Error(ex); } return(ret); }
/// <summary> /// Reads the specified scanline. /// </summary> /// <param name="scanline">The scanline.</param> /// <param name="pixels">The pixels, where the colors should be stored in RGBA format.</param> /// <param name="header">The header, which contains information about the png file, like /// the width of the image and the height.</param> public void ReadScanline(byte[] scanline, byte[] pixels, PngHeader header) { int offset = 0; //byte[] newScanline = scanline.ToArrayByBitsLength(header.BitDepth); byte[] newScanline = IEnum.ToArrayByBitsLength(scanline, header.BitDepth); if (_useAlpha) { for (int x = 0; x < header.Width / 2; x++) { offset = (_row * header.Width + x) * 4; pixels[offset + 0] = newScanline[x * 2]; pixels[offset + 1] = newScanline[x * 2]; pixels[offset + 2] = newScanline[x * 2]; pixels[offset + 3] = newScanline[x * 2 + 1]; } } else { for (int x = 0; x < header.Width; x++) { offset = (_row * header.Width + x) * 4; pixels[offset + 0] = newScanline[x]; pixels[offset + 1] = newScanline[x]; pixels[offset + 2] = newScanline[x]; pixels[offset + 3] = (byte)255; } } _row++; }
private void AddEnumMessages(IEnum enumDefinition) { if (enumDefinition.Name == null) { // The enum name is missing: `enum {}`. this.AddError( CompilerMessageId.EnumMustHaveAName, enumDefinition.Node.ENUM().Symbol); } if (enumDefinition.Name != null && enumDefinition.Parent.IsMemberNameAlreadyDeclared( enumDefinition)) { // Another type has already been declared with the same name: // ``` // struct UserType {} // enum UserType {} // ``` this.AddError( CompilerMessageId.NameAlreadyDeclared, enumDefinition.Node.name, enumDefinition.Node.name.Text); } if (!enumDefinition.Members.Any()) { var warningTarget = enumDefinition.Node.name ?? enumDefinition.Node.ENUM().Symbol; // The enum has no members. For example // `enum MyEnum {}` this.AddWarning(CompilerMessageId.EnumEmpty, warningTarget); } }
//public float GetPropertyValue(PropertyType property, bool absolute, bool valueB = false) //{ // CameraProperty camProp = camera.GetProperty(property); // return (absolute ? camProp.absValue : (!valueB ? camProp.valueA : camProp.valueB)); //} public string GetPropertyValue(string property, bool valueB = false) { if (property == "Shutter") { IFloat node = nodeMap.GetNode <IFloat>("ExposureTime"); return(node.Value.ToString()); } else if (property == "DeviceTemperature") { IFloat node = nodeMap.GetNode <IFloat>("DeviceTemperature"); return(node.Value.ToString()); } else if (property == "WidthMax") { IInteger node = nodeMap.GetNode <IInteger>("WidthMax"); return(node.Value.ToString()); } else if (property == "HeightMax") { IInteger node = nodeMap.GetNode <IInteger>("HeightMax"); return(node.Value.ToString()); } else { IEnum node = nodeMap.GetNode <IEnum>(property); return(node.Value.ToString()); } }
public bool SetWhiteBalanceBlue(double wbBlue) { bool result = false; try { //camera.BalanceRatioSelector.Value = BalanceRatioSelectorEnums.Blue.ToString(); //camera.BalanceRatio.Value = wbBlue; //result = true; IEnum balanceWhiteAuto = nodeMap.GetNode <IEnum>("BalanceWhiteAuto"); balanceWhiteAuto.Value = "Off"; IEnum balanceRatioSelector = nodeMap.GetNode <IEnum>("BalanceRatioSelector"); balanceRatioSelector.Value = "Blue"; IFloat balanceRatio = nodeMap.GetNode <IFloat>("BalanceRatio"); balanceRatio.Value = wbBlue; result = true; } catch (SpinnakerException ex) { Debug.WriteLine("Error: {0}", ex.Message); result = false; } return(result); }
private bool AppendEnumValue([NotNull] ConstantValue constantValue, [NotNull] IEnum enumType) { IList <IField> fields = CSharpEnumUtil.CalculateEnumMembers(constantValue, enumType); if (fields.Count == 0) { return(false); } string typeHighlighterId = _highlighterIdProvider.Enum; string valueHighlighterId = _highlighterIdProvider.Constant; var orderedFields = fields.OrderBy(f => f.ShortName); bool addSeparator = false; foreach (IField orderedField in orderedFields) { if (addSeparator) { AppendText(" | ", _highlighterIdProvider.Operator); } AppendText(enumType.ShortName, typeHighlighterId); AppendText(".", _highlighterIdProvider.Operator); AppendText(orderedField.ShortName, valueHighlighterId); addSeparator = true; } return(true); }
public bool SetSequencerConfigurationMode(bool enable) { bool result = false; try { IEnum iSequencerConfigurationMode = nodeMap.GetNode <IEnum>("SequencerConfigurationMode"); if (iSequencerConfigurationMode == null || !iSequencerConfigurationMode.IsWritable) { throw new Exception("node - SequencerConfigurationMode"); } if (enable) { // // Turn configuration mode on // // *** NOTES *** // Once sequencer mode is off, enabling sequencer configuration // mode allows for the setting of individual sequences. // // *** LATER *** // Before sequencer mode is turned back on, sequencer // configuration mode must be turned off. // IEnumEntry iSequencerConfigurationModeOn = iSequencerConfigurationMode.GetEntryByName("On"); if (iSequencerConfigurationModeOn == null || !iSequencerConfigurationModeOn.IsReadable) { throw new Exception("entry - SequencerConfigurationMode 'On'"); } iSequencerConfigurationMode.Value = iSequencerConfigurationModeOn.Value; } else { // // Turn configuration mode off // // *** NOTES *** // Once all desired states have been set, turn sequencer // configuration mode off in order to turn sequencer mode on. // IEnumEntry iSequencerConfigurationModeOff = iSequencerConfigurationMode.GetEntryByName("Off"); if (iSequencerConfigurationModeOff == null || !iSequencerConfigurationModeOff.IsReadable) { throw new Exception("entry - SequencerConfigurationMode 'Off'"); } iSequencerConfigurationMode.Value = iSequencerConfigurationModeOff.Value; } result = true; } catch (Exception ex) { result = false; } return(result); }
public static IEnumerable <ValidationResult> ValidateEnum(this IEnum @enum, ValidationContext validationContext) { ValidationResult[] results = { ((IValidatableObject)@enum).Is(v => string.IsNullOrWhiteSpace(v), @enum.Name, "Name") }; return(results); }
// Disables heartbeat on GEV cameras so debugging does not incur timeout errors static int DisableHeartbeat(IManagedCamera cam, INodeMap nodeMap, INodeMap nodeMapTLDevice) { Console.WriteLine("Checking device type to see if we need to disable the camera's heartbeat...\n\n"); // // Write to boolean node controlling the camera's heartbeat // // *** NOTES *** // This applies only to GEV cameras and only applies when in DEBUG mode. // GEV cameras have a heartbeat built in, but when debugging applications the // camera may time out due to its heartbeat. Disabling the heartbeat prevents // this timeout from occurring, enabling us to continue with any necessary debugging. // This procedure does not affect other types of cameras and will prematurely exit // if it determines the device in question is not a GEV camera. // // *** LATER *** // Since we only disable the heartbeat on GEV cameras during debug mode, it is better // to power cycle the camera after debugging. A power cycle will reset the camera // to its default settings. // IEnum iDeviceType = nodeMapTLDevice.GetNode <IEnum>("DeviceType"); IEnumEntry iDeviceTypeGEV = iDeviceType.GetEntryByName("GigEVision"); // We first need to confirm that we're working with a GEV camera if (iDeviceType != null && iDeviceType.IsReadable) { if (iDeviceType.Value == iDeviceTypeGEV.Value) { Console.WriteLine( "Working with a GigE camera. Attempting to disable heartbeat before continuing...\n\n"); IBool iGEVHeartbeatDisable = nodeMap.GetNode <IBool>("GevGVCPHeartbeatDisable"); if (iGEVHeartbeatDisable == null || !iGEVHeartbeatDisable.IsWritable) { Console.WriteLine( "Unable to disable heartbeat on camera. Continuing with execution as this may be non-fatal..."); } else { iGEVHeartbeatDisable.Value = true; Console.WriteLine("WARNING: Heartbeat on GigE camera disabled for the rest of Debug Mode."); Console.WriteLine( " Power cycle camera when done debugging to re-enable the heartbeat..."); } } else { Console.WriteLine("Camera does not use GigE interface. Resuming normal execution...\n\n"); } } else { Console.WriteLine("Unable to access TL device nodemap. Aborting..."); return(-1); } return(0); }
protected override TEnum parseNodeValue(IEnum node) { TEnum value; if (!Enum.TryParse(node.Value, out value)) { throw new SpinnakerException("Unable to parse enum '" + NodeName + "' from node value: '" + node.Value + "'"); } return(value); }
public void Copy(IEnum from, IEnum to) { var properties = from.GetType().GetProperties(); foreach (var property in properties) { var value = property.GetValue(from, null); if (property.CanWrite) property.SetValue(to, value, null); } }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { base.GetPropertyHeight(property, label); enumValue = property.GetValue <IEnum>(); enumValues = enumValue.GetValues(); enumNames = enumValue.GetNames().Convert(name => name.Replace('_', '/')); isFlag = enumValue is IEnumFlag; return(16f); }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { base.GetPropertyHeight(property, label); enumValue = property.GetValue<IEnum>(); enumValues = enumValue.GetValues(); enumNames = enumValue.GetNames().Convert(name => name.Replace('_', '/')); isFlag = enumValue is IEnumFlag; return 16f; }
public static string GetEnumName(IEnum enumeration) { //check if there is a source Enum. In that case we use the source enum var enumToUse = enumeration.SourceElement as IEnum; if (enumToUse == null) { enumToUse = enumeration; } return(enumToUse.Name); }
private void AppendConstantValue([NotNull] ConstantValue constantValue) { if (constantValue.IsBadValue()) { AppendText("bad value", null); return; } IEnum enumType = constantValue.Type.GetEnumType(); if (enumType != null && AppendEnumValue(constantValue, enumType)) { return; } string presentation = constantValue.GetPresentation(CSharpLanguage.Instance); if (presentation != null && CSharpLexer.IsKeyword(presentation)) { AppendText(presentation, VsHighlightingAttributeIds.Keyword); return; } IType type = constantValue.Type; if (type != null && type.IsNullable()) { type = type.GetNullableUnderlyingType(); } if (type == null) { AppendText(presentation, null); return; } if (type.IsString()) { AppendText(presentation, VsHighlightingAttributeIds.String); } else if (type.IsChar()) { AppendText(presentation, VsHighlightingAttributeIds.String); } else if (type.IsPredefinedNumeric()) { AppendText(presentation, VsHighlightingAttributeIds.Number); } else { AppendText(presentation, null); } }
/// <summary> /// AcquisitionMode: Continuous/SingleFrame/MutipleFrame /// </summary> /// <param name="strMode"></param> public override bool SetAcquisitionMode(string strMode) { bool ret = false; try { IEnum iAcquisitionMode = m_NodeMap.GetNode <IEnum>("AcquisitionMode"); if (iAcquisitionMode == null || !iAcquisitionMode.IsWritable) { return(ret); } IEnumEntry iAcquisitionModeContinuous; switch (strMode) { case "Continuous": // Retrieve entry node from enumeration node iAcquisitionModeContinuous = iAcquisitionMode.GetEntryByName("Continuous"); if (iAcquisitionModeContinuous == null || !iAcquisitionMode.IsReadable) { return(ret); } break; case "SingleFrame": iAcquisitionModeContinuous = iAcquisitionMode.GetEntryByName("SingleFrame"); if (iAcquisitionModeContinuous == null || !iAcquisitionMode.IsReadable) { return(ret); } break; case "MutipleFrame": iAcquisitionModeContinuous = iAcquisitionMode.GetEntryByName("MutipleFrame"); if (iAcquisitionModeContinuous == null || !iAcquisitionMode.IsReadable) { return(ret); } break; default: return(ret); } // Set symbolic from entry node as new value for enumeration node iAcquisitionMode.Value = iAcquisitionModeContinuous.Symbolic; ret = true; } catch (Exception ex) { LogHelper.AppLoger.Error(ex); } return(ret); }
public void HandleGetSize(TypeHandlingContext context) { IEnum enumType = context.Type.GetEnumType(); if (enumType == null) { throw new NotSupportedException(); } IType baseType = enumType.GetUnderlyingType(); context.Builder.AppendFormat("{1} += sizeof({0});", baseType.GetPresentableName(context.PresentationLanguage), context.GetSizeVariableName()); }
public void AddComponent(byte id, byte factorHorizontal, byte factorVertical, byte quantizationID, byte colorMode) { JpegComponent component = new JpegComponent(this, id, factorHorizontal, factorVertical, quantizationID, colorMode); components.Add(component); // Defined in Annex A //maxH = components.Max(x => x.factorH); //maxV = components.Max(x => x.factorV); maxH = IEnum.Max(components, x => x.factorH); // components.Max(x => x.factorH); maxV = IEnum.Max(components, x => x.factorV); //components.Max(x => x.factorV); }
bool RestoreDefaultSettings() { bool result = false; try { for (int i = 0; i < 3; i++) { try { managedCamera.UserSetSelector.Value = UserSetSelectorEnums.Default.ToString(); managedCamera.UserSetLoad.Execute(); result = true; break; } catch (SpinnakerException s) { managedCamera.AcquisitionMode.Value = AcquisitionModeEnums.Continuous.ToString(); managedCamera.BeginAcquisition(); System.Threading.Thread.Sleep(500); managedCamera.EndAcquisition(); } } //TODO: stream buffer default count mode to manual // Set stream buffer Count Mode to manual // Retrieve Stream Parameters device nodemap INodeMap sNodeMap = managedCamera.GetTLStreamNodeMap(); IEnum streamBufferCountMode = sNodeMap.GetNode <IEnum>("StreamBufferCountMode"); if (streamBufferCountMode == null || !streamBufferCountMode.IsWritable) { return(false); } IEnumEntry streamBufferCountModeManual = streamBufferCountMode.GetEntryByName("Manual"); if (streamBufferCountModeManual == null || !streamBufferCountModeManual.IsReadable) { return(false); } streamBufferCountMode.Value = streamBufferCountModeManual.Value; } catch (Exception ex) { result = false; } return(result); }
public static BaseListSyntax GetBaseList(IEnum item) { if (item.UnderlyingType != null) { var underlyingTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxNode(item.UnderlyingType); underlyingTypeSyntax = BuildSyntaxHelpers.AttachWhitespace( underlyingTypeSyntax, item.UnderlyingType.Whitespace2Set, whitespaceLookup); var colonToken = SyntaxFactory.Token(SyntaxKind.ColonToken); colonToken = BuildSyntaxHelpers.AttachWhitespaceToToken(colonToken, item.Whitespace2Set[LanguageElement.BaseListPrefix]); return(SyntaxFactory.BaseList(colonToken, SyntaxFactory.SingletonSeparatedList <BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(underlyingTypeSyntax)))); } return(null); }
public static EnumContractInfo TryCreate([CanBeNull] IEnum enumType) { if (enumType != null && enumType.HasAttributeInstance(PredefinedType.FLAGS_ATTRIBUTE_CLASS, false)) { var numericTypeInfo = CSharpNumericTypeInfo.TryCreate(enumType.GetUnderlyingType()); if (numericTypeInfo != null) { Debug.Assert(enumType.EnumMembers != null); return(numericTypeInfo.TryCreateEnumFlags(enumType.EnumMembers)); } } return(null); }
protected override void setNodeValue(IEnum node, TEnum value) { IEnumEntry entry = node.GetEntryByName(value.ToString()); if (entry == null) { throw new SpinnakerException("Could not find entry '" + value.ToString() + "' for the node '" + value + "'."); } if (!entry.IsReadable) { throw new SpinnakerException("The entry '" + value.ToString() + "' for the node '" + value + "' is not readable."); } node.Value = entry.Value; }
public static EnumContractInfo TryCreate(IEnum enumType) { if (enumType != null && enumType.HasAttributeInstance(PredefinedType.FLAGS_ATTRIBUTE_CLASS, false)) { var numericTypeInfo = CSharpNumericTypeInfo.TryCreate(enumType.GetUnderlyingType()); if (numericTypeInfo != null) { Debug.Assert(enumType.EnumMembers != null); return numericTypeInfo.TryCreateEnumFlags(enumType.EnumMembers); } } return null; }
public void SetCameraVideoModeAndFrameRate(double newFrameRate) { bool restartCapture = true; try { StopCapture(); } catch (SpinnakerException) { throw; } try { //camera.SetVideoModeAndFrameRate(newVideoMode, newFrameRate); // Set acquisition mode to continuous IEnum iAcquisitionMode = nodeMap.GetNode <IEnum>("AcquisitionMode"); if (iAcquisitionMode == null || !iAcquisitionMode.IsWritable) { Console.WriteLine("Unable to set acquisition mode to continuous (node retrieval). Aborting...\n"); restartCapture = false; } IEnumEntry iAcquisitionModeContinuous = iAcquisitionMode.GetEntryByName("Continuous"); if (iAcquisitionModeContinuous == null || !iAcquisitionMode.IsReadable) { Console.WriteLine("Unable to set acquisition mode to continuous (enum entry retrieval). Aborting...\n"); restartCapture = false; } iAcquisitionMode.Value = iAcquisitionModeContinuous.Symbolic; } catch (SpinnakerException /*ex*/) { throw; } if (!SetFrameRate(newFrameRate)) { restartCapture = false; } if (restartCapture) { StartCapture(); } }
public void addCodeListentries(IEnum enumeration) { //if the enum doesn't contain any values that means that all values are allowed and thus all values of the source enum should be used. var enumToUse = enumeration.CodelistEntries.Any() && (enumeration.SourceElement as IEnum) != null ? enumeration : enumeration.SourceElement as IEnum; //do not add duplicates foreach (var codeListentry in enumToUse.CodelistEntries) { if (!this.codelistEntries.Any(x => x.Name == codeListentry.Name)) { this.codelistEntries.Add(codeListentry); } } }
private void frameRateManualDisable() { IEnum iAcquisitionFrameRateAuto = cam.GetNodeMap().GetNode <IEnum>("AcquisitionFrameRateAuto"); if (iAcquisitionFrameRateAuto == null || !iAcquisitionFrameRateAuto.IsWritable) { Console.WriteLine("无法设置帧率模式\n"); return; } IEnumEntry iAcquisitionFrameRateAutoOff = iAcquisitionFrameRateAuto.GetEntryByName("Continuous"); if (iAcquisitionFrameRateAutoOff == null || !iAcquisitionFrameRateAutoOff.IsReadable) { Console.WriteLine("无法设置启用帧率自动模式\n"); return; } // Set symbolic from entry node as new value for enumeration node iAcquisitionFrameRateAuto.Value = iAcquisitionFrameRateAutoOff.Symbolic; }
public void HandleWrite(TypeHandlingContext context) { IEnum enumType = context.Type.GetEnumType(); if (enumType == null) { throw new NotSupportedException(); } IType baseType = enumType.GetUnderlyingType(); IEnumBaseTypeHandler handler = TypeHandlers.EnumBaseTypeHandlers.SingleOrDefault(h => h.CanHandle(context.WithType(baseType))); if (handler == null) { throw new NotImplementedException(); } handler.HandleEnumWrite(context.TypeOwner, context.Builder, context.Args); }
public bool SetVideoMode(int mode) { try { IEnum iVideoMode = nodeMap.GetNode <IEnum>("VideoMode"); if (iVideoMode == null || !iVideoMode.IsWritable) { return(false); } IEnumEntry iVideoMode0 = iVideoMode.GetEntryByName("Mode0"); if (iVideoMode0 == null || !iVideoMode0.IsReadable) { return(false); } IEnumEntry iVideoMode1 = iVideoMode.GetEntryByName("Mode1"); if (iVideoMode1 == null || !iVideoMode1.IsReadable) { return(false); } if (mode == 0) { iVideoMode.Value = iVideoMode0.Symbolic; } else if (mode == 1) { iVideoMode.Value = iVideoMode1.Symbolic; } else { return(false); } return(true); } catch { return(false); } }
static void Main(string[] args) { try { using (CStApiAutoInit api = new CStApiAutoInit()) using (CStSystem system = new CStSystem(eStSystemVendor.Sentech)) using (CStDevice device = system.CreateFirstStDevice()) using (CStImageDisplayWnd wnd = new CStImageDisplayWnd()) using (CStDataStream dataStream = device.CreateStDataStream(0)) { Console.WriteLine("Device=" + device.GetIStDeviceInfo().DisplayName); // ============================================================================================================== // Saving current setting to UserSet1 of camera, with setting it as default when camera power on. // Please notice the UserSet saving can be only avaliable when camera is not in acquiring. // Create NodeMap pointer for accessing parameters INodeMap nodeMap = device.GetRemoteIStPort().GetINodeMap(); // Select which UserSet to save the setting (UserSet1) IEnum enumUserSetSelector = nodeMap.GetNode <IEnum>("UserSetSelector"); enumUserSetSelector.FromString("UserSet1"); // Acquire and execute saving setting to UserSet ICommand cmdSaveToUserSet = nodeMap.GetNode <ICommand>("UserSetSave"); cmdSaveToUserSet.Execute(); Console.WriteLine("Save Current setting to UserSet1 succeed."); // Set UserSetDefault to UsetSet1 for using this setting when camera power on. IEnum enumUserSetDefault = nodeMap.GetNode <IEnum>("UserSetDefault"); enumUserSetDefault.FromString("UserSet1"); Console.WriteLine("Set UserSetDefault to UserSet1 succeed."); // ============================================================================================================== } } catch (Exception e) { Console.Error.WriteLine("An exception occurred. \r\n" + e.Message); } finally { Console.WriteLine("\r\nPress Enter to exit."); Console.ReadLine(); } }