コード例 #1
0
        /// <summary>
        /// Constructor
        /// </summary>
        private EEPROM_Version_Details_Page()
        {
            resourceManager = new ResourceManager("EEPROM.Properties.Resources", typeof(EEPROM.EEPROM_Version_Details_Page).Assembly);

            byteArrList           = new List <byte[]>();
            DeviceDetailsSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.DeviceDetailsSettings.ToByte <StrutureTypes>()), "");
            DeviceDetailsSettings dds = new EEPROM.DeviceDetailsSettings();

            DeviceDetailsSettings.value = dds;
            InstallationDetailsSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.InstallationDetailsSettings.ToByte <StrutureTypes>()), "");
            InstallationDetailsSettings ids = new EEPROM.InstallationDetailsSettings();

            InstallationDetailsSettings.value = ids;
            Features            = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.Features.ToByte <StrutureTypes>()), "");
            this.Features.value = new EEPROM.Features();
            FFASettings         = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.FFASettings.ToByte <StrutureTypes>()), "");
            FeatureSettings fs = new FeatureSettings();

            FFASettings.value = fs;
            PosteriorSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.PosteriorSettings.ToByte <StrutureTypes>()), "");
            FeatureSettings ps = new FeatureSettings();

            PosteriorSettings.value = ps;
            AnteriorSettings        = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.AnteriorSettings.ToByte <StrutureTypes>()), "");
            FeatureSettings fs1 = new FeatureSettings();

            AnteriorSettings.value = fs1;

            AnteriorBlueSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.AnteriorBlueSettings.ToByte <StrutureTypes>())
                                                                    , "");
            AnteriorBlueSettings.value = new FeatureSettings();
        }
コード例 #2
0
        public VignattingSettings()
        {
            EEPROM_Data_Types <byte> applyVignate = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyVignatting = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyVignate);

            EEPROM_Data_Types <byte> applyLiveParabola = new EEPROM_Data_Types <byte>(1, 0, 1);

            ApplyLiveParabola = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyLiveParabola);

            EEPROM_Data_Types <Int16> vignateRadLive = new EEPROM_Data_Types <Int16>(800, 0, 10000);

            VignattingRadiusLive = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), vignateRadLive);

            EEPROM_Data_Types <Int16> vignatePercentageFactLive = new EEPROM_Data_Types <Int16>(800, 0, 10000);

            VignattingPercentageFactorLive = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), vignatePercentageFactLive);

            EEPROM_Data_Types <Int16> vignateRadiusPostProcessing = new EEPROM_Data_Types <Int16>(1000, 0, 10000);

            VignattingRadiusPostProcessing = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), vignateRadiusPostProcessing);


            EEPROM_Data_Types <Int16> vignatePercentageFactorPostProcessing = new EEPROM_Data_Types <Int16>(1, 0, 10000);

            VignattingPercentageFactorPostProcessing = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), vignatePercentageFactorPostProcessing);
        }
コード例 #3
0
        public PostProcessingSettings()
        {
            ImageShiftSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.ImageShiftSettings.ToByte <StrutureTypes>()), "");
            ImageShiftSettings.value = new EEPROM.ImageShiftSettings();
            VignattingSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.VignattingSettings.ToByte <StrutureTypes>()), "");

            VignattingSettings.value = new EEPROM.VignattingSettings();
            MaskSettings             = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.MaskSettings.ToByte <StrutureTypes>()), "");

            MaskSettings.value      = new EEPROM.MaskSettings();
            ColorCorrectionSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.ColorCorrectionSettings.ToByte <StrutureTypes>()), "");

            ColorCorrectionSettings.value = new EEPROM.ColorCorrectionSettings();
            HotSpotSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.HotSpotCorrectionSettings.ToByte <StrutureTypes>()), "");

            HotSpotSettings.value = new EEPROM.HotSpotSettings();
            UnsharpMaskSettings   = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.UnsharpMaskSettings.ToByte <StrutureTypes>()), "");

            UnsharpMaskSettings.value = new EEPROM.UnsharpMaskSettings();

            ClaheSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.ClaheSettings.ToByte <StrutureTypes>()), "");

            ClaheSettings.value = new EEPROM.ClaheSettings();
            LutSettings         = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.LutSettings.ToByte <StrutureTypes>()), "");

            LutSettings.value                = new EEPROM.LutSettings();
            BrightnessContrastSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.BrightnessContrastSettings.ToByte <StrutureTypes>()), "");
            BrightnessContrastSettings.value = new EEPROM.BrightnessContrastSettings();
        }
コード例 #4
0
        private void PopulateEEPROMDic()
        {
            if (detailsPage == null)
            {
                detailsPage = EEPROM_Version_Details_Page.GetInstance();
            }
            if (t == null)
            {
                t = new TabControl();
            }
            t.Multiline = true;

            t.Size = new System.Drawing.Size(this.Width, this.Height - (int)tableLayoutPanel1.RowStyles[1].Height);

            foreach (KeyValuePair <object, object> val in  detailsPage.fieldDic)
            {
                TabPage      tPage     = new TabPage();
                string       output    = "";
                EEPROM_Props eepromTab = val.Key as EEPROM_Props;
                tPage.Text       = eepromTab.text;
                tPage.AutoScroll = true;
                config.vIndent   = 10;
                string parentName      = "Settings";
                string strutureTypeStr = StrutureTypes.FeatureSettings.ToString();
                config.addBranchL(val, "Settings", 1, tPage);
                t.Controls.Add(tPage);
            }
            t.Dock = DockStyle.Fill;
            tableLayoutPanel1.Controls.Add(t, 0, 0);
        }
コード例 #5
0
        public InstallationDetailsSettings()
        {
            byte[] emailArr = new byte[64];
            Array.Copy(Encoding.UTF8.GetBytes("*****@*****.**"), emailArr, Encoding.UTF8.GetBytes("*****@*****.**").Length);
            ContactEmail = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 64), "*****@*****.**");


            byte[] numberArr = new byte[40];
            Array.Copy(Encoding.UTF8.GetBytes("9739460868"), numberArr, Encoding.UTF8.GetBytes("9739460868").Length);
            ContactNumber = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 40), "9739460868");

            byte[] countryArr = new byte[24];
            Array.Copy(Encoding.UTF8.GetBytes("India"), countryArr, Encoding.UTF8.GetBytes("India").Length);
            InstallationCountry = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 24), "India");

            byte[] stateArr = new byte[32];// Encoding.UTF8.GetBytes("Karnataka");
            Array.Copy(Encoding.UTF8.GetBytes("Karnataka"), stateArr, Encoding.UTF8.GetBytes("Karnataka").Length);
            InstallationState = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 32), "Karnataka");

            byte[] pincodeArr = new byte[32];// Encoding.UTF8.GetBytes("560085");
            Array.Copy(Encoding.UTF8.GetBytes("560085"), pincodeArr, Encoding.UTF8.GetBytes("560085").Length);
            InstallationPinCode = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 32), "560085");

            byte[] cityArr = new byte[24];// Encoding.UTF8.GetBytes("Bangalore");
            Array.Copy(Encoding.UTF8.GetBytes("Bangalore"), cityArr, Encoding.UTF8.GetBytes("Bangalore").Length);
            InstallationCity = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 24), "Bangalore");

            byte[] siteArr = new byte[40];// Encoding.UTF8.GetBytes("Girinagar");
            Array.Copy(Encoding.UTF8.GetBytes("Girinagar"), emailArr, Encoding.UTF8.GetBytes("Girinagar").Length);
            Installation_Site = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 40), "Girinagar");
        }
コード例 #6
0
        public ShadowCorrectionSettings()
        {
            EEPROM_Data_Types <Int16> hsRad1 = new EEPROM_Data_Types <Int16>(-20, -1000, 1000);

            HotspotRadius1 = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), hsRad1);

            EEPROM_Data_Types <Int16> hsRad2 = new EEPROM_Data_Types <Int16>(100, -1000, 1000);

            HotspotRadius2 = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), hsRad2);


            EEPROM_Data_Types <Int16> shadowRad1 = new EEPROM_Data_Types <Int16>(170, -1000, 1000);

            ShadowRadSpot1 = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), shadowRad1);

            EEPROM_Data_Types <Int16> shadowRad2 = new EEPROM_Data_Types <Int16>(400, -1000, 1000);

            ShadowRadSpot2 = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), shadowRad2);


            EEPROM_Data_Types <byte> redPer = new EEPROM_Data_Types <byte>(20, byte.MinValue, byte.MaxValue);

            ShadowRedPercentage = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), redPer);

            EEPROM_Data_Types <byte> greenPer = new EEPROM_Data_Types <byte>(15, byte.MinValue, byte.MaxValue);

            ShadowGreenPercentage = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), greenPer);

            EEPROM_Data_Types <byte> bluePer = new EEPROM_Data_Types <byte>(10, byte.MinValue, byte.MaxValue);

            ShadowBluePercentage = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), bluePer);
        }
コード例 #7
0
        public TemperatureTintSettings()
        {
            EEPROM_Data_Types <byte> captureEnableCC = new EEPROM_Data_Types <byte>(1, 0, 1);

            CaptureEnableCC = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), captureEnableCC);

            EEPROM_Data_Types <byte> captureEnableWB = new EEPROM_Data_Types <byte>(1, 0, 1);

            CaptureEnableWB = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), captureEnableWB);

            EEPROM_Data_Types <byte> liveEnableCC = new EEPROM_Data_Types <byte>(1, 0, 1);

            LiveEnableCC = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), liveEnableCC);

            EEPROM_Data_Types <byte> liveEnableWB = new EEPROM_Data_Types <byte>(1, 0, 1);

            LiveEnableWB = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), liveEnableWB);

            EEPROM_Data_Types <Int16> liveTint = new EEPROM_Data_Types <Int16>(1000, 1, 2500);


            LiveTint = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveTint);

            EEPROM_Data_Types <Int16> captureTint = new EEPROM_Data_Types <Int16>(1000, 1, 2500);

            CaptureTint = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureTint);

            EEPROM_Data_Types <Int16> liveTemp = new EEPROM_Data_Types <Int16>(5500, 1, 15000);

            LiveTemperature = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveTemp);

            EEPROM_Data_Types <Int16> captureTemp = new EEPROM_Data_Types <Int16>(5500, 1, 15000);

            CaptureTemperature = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureTemp);
        }
コード例 #8
0
ファイル: Config_UC.cs プロジェクト: SriramSigtuple/Intusoft
        public void addBranchL(KeyValuePair <object, Object> branch, String parentName, int iLevel, Control c)
        {
            EEPROM_Props branchKeyEEPROM = branch.Key as EEPROM_Props;
            XmlLeaf_UC   tmp             = new XmlLeaf_UC(branchKeyEEPROM.text, branchKeyEEPROM.eepromDataType.dataType, branchKeyEEPROM.value, parentName, iLevel);

            tmp.Left = hIndent + (iLevel - 1) * 30;
            tmp.Top  = vIndent;
            c.Controls.Add(tmp);
            vIndent += 30;
            foreach (KeyValuePair <object, Object> pair in branch.Value as Dictionary <Object, object> )
            {
                EEPROM_Props pairKeyEEPROM = null;
                if (pair.Key is EEPROM_Props)
                {
                    pairKeyEEPROM = pair.Key as EEPROM_Props;
                }
                else
                {
                    pairKeyEEPROM = pair.Value as EEPROM_Props;
                }

                if (pairKeyEEPROM.eepromDataType.dataType != DataTypes.Tree)
                {
                    addLeaf(pairKeyEEPROM, iLevel, parentName + "." + branchKeyEEPROM.name, c);
                }
                else
                {
                    addBranchL(pair, parentName + "." + branchKeyEEPROM.name, iLevel + 1, c);
                }
            }
        }
コード例 #9
0
        public FirmwareSettings()
        {
            EEPROM_Data_Types <byte> enableSingleFrameVal = new EEPROM_Data_Types <byte>(1, 0, 1);

            EnableSingleFrameCapture = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableSingleFrameVal);;

            EEPROM_Data_Types <byte> isUSBCom = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsUSBCommunication = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), isUSBCom);;
            EEPROM_Data_Types <byte> isFlashBoost = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsFlashBoost = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), isFlashBoost);;
            EEPROM_Data_Types <byte> enableLeftRightSensor = new EEPROM_Data_Types <byte>(1, 0, 1);

            EnableLeftRightSensor = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableLeftRightSensor);;
            EEPROM_Data_Types <byte> boardIter = new EEPROM_Data_Types <byte>(2, 0, 10);

            BoardCommandIteration = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), boardIter);
            EEPROM_Data_Types <UInt16> camInt = new EEPROM_Data_Types <UInt16>(1000, 0, UInt16.MaxValue);

            CameraPowerTimerInterval = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.UInt16, 2), camInt);
            EEPROM_Data_Types <byte> flashOffsetStart = new EEPROM_Data_Types <byte>(90, 1, byte.MaxValue);


            FlashOffsetStart = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), flashOffsetStart);

            EEPROM_Data_Types <byte> flashOffsetEnd = new EEPROM_Data_Types <byte>(10, 1, byte.MaxValue);

            FlashOffsetEnd = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), flashOffsetEnd);

            EEPROM_Data_Types <byte> flashBoostVal = new EEPROM_Data_Types <byte>(95, 1, byte.MaxValue);

            FlashBoostValue = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), flashBoostVal);
        }
コード例 #10
0
        public HotSpotSettings()
        {
            ShadowSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.ShadowCorrectionSettings.ToByte <StrutureTypes>()), "", "0");
            ShadowSettings.value = new ShadowCorrectionSettings();

            HSCorrectionSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.HotSpotCorrectionSettings.ToByte <StrutureTypes>()), "", "0");
            HSCorrectionSettings.value = new HotSpotCorrectionSettings();
        }
コード例 #11
0
ファイル: Config_UC.cs プロジェクト: SriramSigtuple/Intusoft
        private void addLeaf(EEPROM_Props ctrl, int lvl, string parentName, Control c)
        {
            XmlLeaf_UC node = new XmlLeaf_UC(ctrl.text, ctrl.eepromDataType.dataType, ctrl, parentName, lvl);

            node.Left = hIndent + 5 * lvl;
            node.Top  = vIndent;
            vIndent  += 30;
            c.Controls.Add(node);
        }
コード例 #12
0
        public void CreateEEPROMPropsFromByteArr(PageDetails details, Dictionary <object, object> ByteArrDic, PropertyInfo[] pinf, object obj)
        {
            EEPROM_Props val = null;

            for (int i = 0; i < details.NumberOfStructures; i++)
            {
                StructureDetails structDetails = details.details[i];
                if (structDetails.NumberOfBytes == 0)
                {
                    object         result  = GetSettingsInstanceFromStructureType(structDetails.TypeOfStructure);
                    StrutureTypes  st      = (StrutureTypes)structDetails.TypeOfStructure;
                    byte[]         arr     = byteArrList[structDetails.StructStartPage];
                    PropertyInfo[] propInf = result.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
                    val             = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, structDetails.TypeOfStructure), result);
                    val.name        = st.ToString();
                    val.text        = resourceManager.GetString(val.name);
                    val.PageDetails = GetPageDetailsFromByteArr(arr);
                    Dictionary <object, object> dic = new Dictionary <object, object>();
                    offset = 0;
                    CreateEEPROMPropsFromByteArr(val.PageDetails, dic, propInf, result);
                    ByteArrDic.Add(val, dic);
                }
                else
                {
                    val      = pinf[i].GetValue(obj) as EEPROM_Props;
                    val.name = pinf[i].Name;
                    val.text = resourceManager.GetString(val.name);
                    byte[] arr = new Byte[details.details[i].NumberOfBytes];

                    if (details.details[i].StuctNumberOfPages > 1)
                    {
                        byte[] byteArr1 = byteArrList[details.details[i].StructStartPage];
                        Array.Copy(byteArr1, offset, arr, 0, pageSize - offset);
                        byte[] byteArr2 = byteArrList[details.details[i].StructStartPage + 1];
                        Array.Copy(byteArr2, 0, arr, pageSize - offset, arr.Length - (pageSize - offset));
                    }
                    else
                    {
                        byteArr = byteArrList[details.details[i].StructStartPage];
                        Array.Copy(byteArr, offset, arr, 0, arr.Length);
                    }
                    val.GetValFromBytes(arr);
                    ByteArrDic.Add("EEPROM." + val.name, val);
                    offset += details.details[i].NumberOfBytes;
                    if (offset > pageSize)
                    {
                        offset = (byte)((int)offset - (int)pageSize);
                    }
                    else if (offset == pageSize)
                    {
                        offset = 0;
                    }
                }
            }
        }
コード例 #13
0
        public CameraSettings()
        {
            GainExposureSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.ExposureGainSettings.ToByte <StrutureTypes>()), "");
            GainExposureSettings.value = new EEPROM.ExposureGainSettings();

            CameraModeSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.CameraModeSettings.ToByte <StrutureTypes>()), "");
            CameraModeSettings.value = new EEPROM.CameraModeSettings();

            TemperatureTintSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.TemperatureTintSettings.ToByte <StrutureTypes>()), "");
            TemperatureTintSettings.value = new EEPROM.TemperatureTintSettings();
        }
コード例 #14
0
        public CurrentVoltageSettings()
        {
            EEPROM_Data_Types <float> liveModeCurrentVal = new EEPROM_Data_Types <float>(0.4f, 0f, 3f);

            Live_Mode_Current_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), liveModeCurrentVal);

            EEPROM_Data_Types <byte> liveModeMaxPer = new EEPROM_Data_Types <byte>(50, 0, 100);

            Live_Mode_Max_Percentage = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), liveModeMaxPer);

            EEPROM_Data_Types <byte> liveModeCurrentBoostVal = new EEPROM_Data_Types <byte>(0, 0, 100);

            Live_Mode_Current_Boost_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), liveModeCurrentBoostVal);

            EEPROM_Data_Types <byte> liveModeCurrentBoostEnable = new EEPROM_Data_Types <byte>(0, 0, 1);

            Live_Mode_Current_Boost_Enable = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), liveModeCurrentBoostEnable);

            EEPROM_Data_Types <byte> liveModeMaxIntVal = new EEPROM_Data_Types <byte>(150, byte.MinValue, byte.MaxValue);

            Live_Mode_Max_Int_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), liveModeMaxIntVal);

            EEPROM_Data_Types <float> liveModeVoltageVal = new EEPROM_Data_Types <float>(0f, 0f, 6f);

            Live_Mode_Voltage_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), liveModeVoltageVal);


            EEPROM_Data_Types <float> captureModeCurrentVal = new EEPROM_Data_Types <float>(0.4f, 0f, 3f);

            Capture_Mode_Current_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), captureModeCurrentVal);

            EEPROM_Data_Types <byte> captureModeMaxPer = new EEPROM_Data_Types <byte>(50, 0, 100);

            Capture_Mode_Max_Percentage = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), captureModeMaxPer);

            EEPROM_Data_Types <byte> captureModeCurrentBoostVal = new EEPROM_Data_Types <byte>(0, 0, 100);

            Capture_Mode_Current_Boost_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), captureModeCurrentBoostVal);

            EEPROM_Data_Types <byte> captureModeCurrentBoostEnable = new EEPROM_Data_Types <byte>(0, 0, 1);

            Capture_Mode_Current_Boost_Enable = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), captureModeCurrentBoostEnable);

            EEPROM_Data_Types <byte> captureModeMaxIntVal = new EEPROM_Data_Types <byte>(150, byte.MinValue, byte.MaxValue);

            Capture_Mode_Max_Int_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), captureModeMaxIntVal);

            EEPROM_Data_Types <float> captureModeVoltageVal = new EEPROM_Data_Types <float>(0f, 0f, 6f);

            Capture_Mode_Voltage_Value = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), captureModeVoltageVal);
        }
コード例 #15
0
        public ExposureGainSettings()
        {
            EEPROM_Data_Types <Int16> liveGainLow = new EEPROM_Data_Types <Int16>(100, 100, 5000);

            LiveGainLow = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveGainLow);

            EEPROM_Data_Types <Int16> liveGainMed = new EEPROM_Data_Types <Int16>(100, 100, 5000);

            LiveGainMedium = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveGainMed);

            EEPROM_Data_Types <Int16> liveGainHigh = new EEPROM_Data_Types <Int16>(300, 100, 5000);

            LiveGainHigh = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveGainHigh);

            EEPROM_Data_Types <Int16> captureGainLow = new EEPROM_Data_Types <Int16>(100, 100, 5000);

            CaptureGainLow = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureGainLow);

            EEPROM_Data_Types <Int16> captureGainMed = new EEPROM_Data_Types <Int16>(200, 100, 5000);

            CaptureGainMedium = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureGainMed);

            EEPROM_Data_Types <Int16> captureGainHigh = new EEPROM_Data_Types <Int16>(300, 100, 5000);

            CaptureGainHigh = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureGainHigh);

            EEPROM_Data_Types <Int16> captureGain = new EEPROM_Data_Types <Int16>(100, 100, 5000);

            CaptureGain = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureGain);

            EEPROM_Data_Types <Int16> liveGain = new EEPROM_Data_Types <Int16>(100, 100, 5000);

            LiveGain = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveGain);

            EEPROM_Data_Types <Int32> liveExposure = new EEPROM_Data_Types <Int32>(77376, 2500, 300000);

            LiveExposure = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int32, 4), liveExposure);

            EEPROM_Data_Types <Int32> captureExposure = new EEPROM_Data_Types <Int32>(77376, 2500, 300000);

            CaptureExposure = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int32, 4), captureExposure);

            EEPROM_Data_Types <Int16> liveGainDefault = new EEPROM_Data_Types <Int16>(1, 1, 10);

            LiveGainDefault = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 4), liveGainDefault);

            EEPROM_Data_Types <byte> captureGainDefault = new EEPROM_Data_Types <byte>(1, 1, 10);

            CaptureGainDefault = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), captureGainDefault);
        }
コード例 #16
0
        public ImageShiftSettings()
        {
            EEPROM_Data_Types <byte> shiftValue = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyImageShift = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), shiftValue);

            EEPROM_Data_Types <byte> shiftX = new EEPROM_Data_Types <byte>(4, byte.MinValue, byte.MaxValue);

            ImageShiftX = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 2), shiftX);

            EEPROM_Data_Types <byte> shiftY = new EEPROM_Data_Types <byte>(4, byte.MinValue, byte.MaxValue);

            ImageShiftY = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 2), shiftY);
        }
コード例 #17
0
 public FeatureSettings()
 {
     FirmwareSettings             = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.FirmwareSettings.ToByte <StrutureTypes>()), ""); // new FirmwareSettings();
     FirmwareSettings.value       = new EEPROM.FirmwareSettings();
     PostProcessingSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.PostProcessingSettings.ToByte <StrutureTypes>()), "");
     PostProcessingSettings.value = new EEPROM.PostProcessingSettings();
     CameraSettings               = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.CameraSettings.ToByte <StrutureTypes>()), "");
     CameraSettings.value         = new EEPROM.CameraSettings();
     CurrentVoltageSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.CurrentVoltageSettings.ToByte <StrutureTypes>()), "");
     CurrentVoltageSettings.value = new EEPROM.CurrentVoltageSettings();
     ImageSizeSettings            = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.ImageSizeSettings.ToByte <StrutureTypes>()), "");
     ImageSizeSettings.value      = new EEPROM.ImageSizeSettings();
     MotorSettings       = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Tree, StrutureTypes.MotorSettings.ToByte <StrutureTypes>()), "");
     MotorSettings.value = new EEPROM.MotorSettings();
 }
コード例 #18
0
        public ClaheSettings()
        {
            EEPROM_Data_Types <byte> applyClaheVal = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyClaheSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyClaheVal);;

            EEPROM_Data_Types <float> _ClipValueRVal = new EEPROM_Data_Types <float>(0.002f, 0f, 1f);

            ClipValueR = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), _ClipValueRVal);
            EEPROM_Data_Types <float> _ClipValueGVal = new EEPROM_Data_Types <float>(0.002f, 0f, 1f);

            ClipValueG = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), _ClipValueGVal);
            EEPROM_Data_Types <float> _ClipValueBVal = new EEPROM_Data_Types <float>(0.002f, 0f, 1f);

            ClipValueB = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), _ClipValueBVal);
        }
コード例 #19
0
        public static void SetValueIterate(Dictionary <object, object> tempDic, string[] nodes, int index, object val)
        {
            foreach (KeyValuePair <object, object> item in tempDic)
            {
                if (isChangeValueSaved)
                {
                    break;
                }
                if (index < nodes.Length - 1 && item.Key is EEPROM_Props)
                {
                    EEPROM_Props keyEEPROM = item.Key as EEPROM_Props;

                    if ((keyEEPROM.name == nodes[index]))
                    {
                        index += 1;
                        SetValueIterate(item.Value as Dictionary <object, object>, nodes, index, val);
                        if (isChangeValueSaved)
                        {
                            break;
                        }
                    }
                }
                else
                {
                    if (item.Key is string)
                    {
                        EEPROM_Props changeValEepromProps = item.Value as EEPROM_Props;

                        if (changeValEepromProps.text == nodes[index])
                        {
                            if (changeValEepromProps.eepromDataType.dataType == DataTypes.ByteArr)
                            {
                                changeValEepromProps.value = val;
                            }
                            else
                            {
                                string str     = changeValEepromProps.eepromDataType.dataType.ToString();
                                Type   typeVal = Type.GetType(str);
                                changeValEepromProps.SetEEPROM_DataType_Value(val, SetValueItem.Value);
                                isChangeValueSaved = true;
                                break;
                            }
                        }
                    }
                }
            }
        }
コード例 #20
0
        public void SetFromByteArrDicToCurrentVersionDic(Dictionary <object, object> src, Dictionary <object, object> dest)
        {
            for (int i = 0; i < src.Count; i++)
            {
                var          srcItem     = src.ElementAt(i);
                EEPROM_Props srcItemKey  = srcItem.Key  as EEPROM_Props;
                string       srcKeyName  = "";
                string       destKeyName = "";
                if (srcItemKey == null)
                {
                    srcKeyName = srcItem.Key.ToString();
                }
                else
                {
                    srcKeyName = srcItemKey.name;
                }
                var srcItemValue = srcItem.Value;

                var          destItem      = dest.ElementAt(i);
                EEPROM_Props destItemKey   = destItem.Key as EEPROM_Props;
                var          destItemValue = destItem.Value;
                if (destItemKey == null)
                {
                    destKeyName = destItem.Key.ToString();
                }
                else
                {
                    destKeyName = destItemKey.name;
                }
                if (srcKeyName == destKeyName)
                {
                    if (srcItemKey != null)
                    {
                        Dictionary <object, object> srcDic  = srcItemValue as Dictionary <object, object>;
                        Dictionary <object, object> destDic = destItemValue as Dictionary <object, object>;
                        SetFromByteArrDicToCurrentVersionDic(srcDic, destDic);
                    }
                    else
                    {
                        EEPROM_Props srcValue  = srcItem.Value as EEPROM_Props;
                        EEPROM_Props destValue = destItem.Value as EEPROM_Props;
                        destValue.value = srcValue.value;
                    }
                }
            }
        }
コード例 #21
0
        public Features()
        {
            EEPROM_Data_Types <byte> enableAnterior = new EEPROM_Data_Types <byte>(1, 0, 1);

            AnteriorEnable = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableAnterior);

            EEPROM_Data_Types <byte> enableAnteriorBlue = new EEPROM_Data_Types <byte>(1, 0, 1);

            AnteriorBlueEnable = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableAnteriorBlue);

            EEPROM_Data_Types <byte> enablePosterior = new EEPROM_Data_Types <byte>(1, 0, 1);

            PosteriorEnable = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enablePosterior);

            EEPROM_Data_Types <byte> enableFFA = new EEPROM_Data_Types <byte>(1, 0, 1);

            fFAEnable = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableFFA);
        }
コード例 #22
0
        public BrightnessContrastSettings()
        {
            EEPROM_Data_Types <byte> applyContrastVal = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyContrast = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyContrastVal);

            EEPROM_Data_Types <byte> applyBrightnessVal = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyBrightness = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyBrightnessVal);


            EEPROM_Data_Types <byte> BrightnessValue = new EEPROM_Data_Types <byte>(3, 0, 100);

            BrightnessVal = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), BrightnessValue);

            EEPROM_Data_Types <sbyte> ContrastValue = new EEPROM_Data_Types <sbyte>(1, -20, 20);

            ContrastVal = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.SByte, 1), ContrastValue);
        }
コード例 #23
0
        public ImageSizeSettings()
        {
            EEPROM_Data_Types <Int16> liveImageWidth = new EEPROM_Data_Types <Int16>(3072, 0, 10000);

            LiveImageWidth = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveImageWidth);;

            EEPROM_Data_Types <Int16> liveImageHeight = new EEPROM_Data_Types <Int16>(2048, 0, 10000);

            LiveImageHeight = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveImageHeight);;

            EEPROM_Data_Types <Int16> liveImageROIX = new EEPROM_Data_Types <Int16>(270, 0, 10000);

            LiveImageROIX = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveImageROIX);;

            EEPROM_Data_Types <Int16> liveImageROIY = new EEPROM_Data_Types <Int16>(270, 0, 10000);

            LiveImageROIY = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), liveImageROIY);;

            EEPROM_Data_Types <Int16> captureImageWidth = new EEPROM_Data_Types <Int16>(3072, 0, 10000);

            CaptureImageWidth = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureImageWidth);;

            EEPROM_Data_Types <Int16> captureImageHeight = new EEPROM_Data_Types <Int16>(2048, 0, 10000);

            CaptureImageHeight = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureImageHeight);;

            EEPROM_Data_Types <Int16> captureImageROIX = new EEPROM_Data_Types <Int16>(270, 0, 10000);

            CaptureImageROIX = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureImageROIX);;

            EEPROM_Data_Types <Int16> captureImageROIY = new EEPROM_Data_Types <Int16>(270, 0, 10000);

            CaptureImageROIY = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), captureImageROIY);;

            EEPROM_Data_Types <Int16> imageOpticalCentreX = new EEPROM_Data_Types <Int16>(1536, 0, 10000);

            ImageOpticalCentreX = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), imageOpticalCentreX);;

            EEPROM_Data_Types <Int16> imageOpticalCentreY = new EEPROM_Data_Types <Int16>(1024, 0, 10000);

            ImageOpticalCentreY = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), imageOpticalCentreY);;
        }
コード例 #24
0
        public LutSettings()
        {
            EEPROM_Data_Types <byte> applyLut = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyLutSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyLut);


            EEPROM_Data_Types <byte> lutSineFactor = new EEPROM_Data_Types <byte>(40, byte.MinValue, byte.MaxValue);

            LutSineFactor = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), lutSineFactor);

            EEPROM_Data_Types <byte> lutInt1 = new EEPROM_Data_Types <byte>(50, byte.MinValue, byte.MaxValue);

            LutInterval1 = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), lutInt1);
            EEPROM_Data_Types <byte> lutInt2 = new EEPROM_Data_Types <byte>(130, byte.MinValue, byte.MaxValue);

            LutInterval2 = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), lutInt2);
            EEPROM_Data_Types <byte> lutOffset = new EEPROM_Data_Types <byte>(25, byte.MinValue, byte.MaxValue);

            LutOffset = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), lutOffset);
        }
コード例 #25
0
        public UnsharpMaskSettings()
        {
            EEPROM_Data_Types <byte> applyUnsharp = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyUnsharpSettings = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyUnsharp);

            EEPROM_Data_Types <float> unsharpAmount = new EEPROM_Data_Types <float>(0.5f, 0f, 10f);

            UnSharpAmount = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), unsharpAmount);

            EEPROM_Data_Types <byte> unsharpRadius = new EEPROM_Data_Types <byte>(9, byte.MinValue, byte.MaxValue);

            UnSharpRadius = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), unsharpRadius);

            EEPROM_Data_Types <byte> unsharpThreshold = new EEPROM_Data_Types <byte>(40, byte.MinValue, byte.MaxValue);

            UnSharpThreshold = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), unsharpThreshold);

            EEPROM_Data_Types <byte> medFilter = new EEPROM_Data_Types <byte>(3, byte.MinValue, byte.MaxValue);

            MedFilter = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), medFilter);
        }
コード例 #26
0
        public MotorSettings()
        {
            EEPROM_Data_Types <byte> applyPly = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyPly = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyPly);

            EEPROM_Data_Types <byte> PolarityForward = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsMotorPolarityForward = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), PolarityForward);

            EEPROM_Data_Types <byte> isMotorCompensation = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsMotorCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), isMotorCompensation);

            EEPROM_Data_Types <byte> IR2FlashSteps = new EEPROM_Data_Types <byte>(1, 0, 1);

            MotorCompensationStepsIR2Flash = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), IR2FlashSteps);

            EEPROM_Data_Types <Int16> motorEndBack = new EEPROM_Data_Types <Int16>(400, 0, 10000);

            Motor_EndPoint_Backward = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), motorEndBack);
            EEPROM_Data_Types <Int16> motorEndForw = new EEPROM_Data_Types <Int16>(600, 0, 10000);

            Motor_EndPoint_Forward = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), motorEndForw);

            EEPROM_Data_Types <Int16> motorZeroD = new EEPROM_Data_Types <Int16>(0, 0, 10000);

            Motor_ZeroD_Position = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), motorZeroD);
            EEPROM_Data_Types <Int16> motorResetPos = new EEPROM_Data_Types <Int16>(0, 0, 10000);

            Motor_Reset_Position = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), motorResetPos);
            EEPROM_Data_Types <Int16> motorStepsRange = new EEPROM_Data_Types <Int16>(0, 0, 10000);

            Motor_Steps_Range = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 2), motorStepsRange);

            EEPROM_Data_Types <byte> plySetps = new EEPROM_Data_Types <byte>(1, 0, byte.MaxValue);

            MotorPlySteps = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), plySetps);
        }
コード例 #27
0
        public DeviceDetailsSettings()
        {
            byte[] deviceNumberArr = new byte[16];
            Array.Copy(Encoding.UTF8.GetBytes("01-1701-0000"), deviceNumberArr, Encoding.UTF8.GetBytes("01-1701-0000").Length);
            Device_number = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 12), "01-1701-0000");

            byte[] modelArr = new byte[16];
            Array.Copy(Encoding.UTF8.GetBytes("INTUCAM-45"), modelArr, Encoding.UTF8.GetBytes("INTUCAM-45").Length);
            Model = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 16), "INTUCAM-45");

            byte[] prodBactchArr = new byte[8];
            Array.Copy(Encoding.UTF8.GetBytes("1701"), prodBactchArr, Encoding.UTF8.GetBytes("1701").Length);
            Production_batch = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 8), "1701");

            byte[] opticsVerArr = new byte[8]; Encoding.UTF8.GetBytes("1.0.A");
            Array.Copy(Encoding.UTF8.GetBytes("1.0.A"), opticsVerArr, Encoding.UTF8.GetBytes("1.0.A").Length);
            Optics_Version = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 8), "1.0.A");

            byte[] camModelArr = new byte[8];
            Array.Copy(Encoding.UTF8.GetBytes("V1M1"), camModelArr, Encoding.UTF8.GetBytes("V1M1").Length);// = (Vendor 1, Model 1)");
            Camera_model = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.ByteArr, 8), "V1M1");
        }
コード例 #28
0
        public ColorCorrectionSettings()
        {
            EEPROM_Data_Types <byte> applyCC = new EEPROM_Data_Types <byte>(1, 0, 1);

            IsApplyColorCorrection = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyCC);

            EEPROM_Data_Types <float> rr = new EEPROM_Data_Types <float>(1.3f, -10f, 10f);

            RRCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), rr);

            EEPROM_Data_Types <float> rg = new EEPROM_Data_Types <float>(0.2f, -10f, 10f);

            RGCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), rg);

            EEPROM_Data_Types <float> rb = new EEPROM_Data_Types <float>(0f, -10f, 10f);

            RBCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), rb);

            EEPROM_Data_Types <float> gr = new EEPROM_Data_Types <float>(0f, -10f, 10f);

            GRCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), gr);
            EEPROM_Data_Types <float> gg = new EEPROM_Data_Types <float>(0.95f, -10f, 10f);

            GGCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), gg);

            EEPROM_Data_Types <float> gb = new EEPROM_Data_Types <float>(0f, -10f, 10f);

            GBCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), gb);
            EEPROM_Data_Types <float> br = new EEPROM_Data_Types <float>(0f, -10f, 10f);

            BRCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), br);
            EEPROM_Data_Types <float> bg = new EEPROM_Data_Types <float>(0.2f, -10f, 10f);

            BGCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), bg);
            EEPROM_Data_Types <float> bb = new EEPROM_Data_Types <float>(1.3f, -10f, 10f);

            BBCompensation = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), bb);
        }
コード例 #29
0
        public CameraModeSettings()
        {
            EEPROM_Data_Types <byte> cameraModel = new EEPROM_Data_Types <byte>(1, 1, byte.MaxValue);

            CameraModel = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), cameraModel, "A,B,C,D");

            EEPROM_Data_Types <byte> saveFrameCnt = new EEPROM_Data_Types <byte>(8, 1, byte.MaxValue);

            SaveFramesCount = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), saveFrameCnt);

            EEPROM_Data_Types <byte> darkFrameDetectVal = new EEPROM_Data_Types <byte>(100, 1, byte.MaxValue);

            DarkFrameDetectionValue = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), darkFrameDetectVal);

            EEPROM_Data_Types <byte> enableRawMode = new EEPROM_Data_Types <byte>(1, 0, 1);

            EnableRawMode = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableRawMode);

            EEPROM_Data_Types <byte> enable14Bit = new EEPROM_Data_Types <byte>(1, 0, 1);

            Enable14Bit = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enable14Bit);

            EEPROM_Data_Types <byte> enableVerticalFlip = new EEPROM_Data_Types <byte>(1, 0, 1);

            EnableVerticalFlip = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableVerticalFlip);

            EEPROM_Data_Types <byte> enableHorizontalFlip = new EEPROM_Data_Types <byte>(1, 0, 1);

            EnableHorizontalFlip = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), enableHorizontalFlip);



            EEPROM_Data_Types <float> frameDetectVal = new EEPROM_Data_Types <float>(2.5f, 0f, 100f);

            FrameDetectionValue = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Single, 4), frameDetectVal);
        }
コード例 #30
0
        public HotSpotCorrectionSettings()
        {
            EEPROM_Data_Types <byte> applyHS = new EEPROM_Data_Types <byte>(0, byte.MinValue, 1);

            IsApplyHotspotCorrection = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), applyHS);


            EEPROM_Data_Types <byte> gainSlope = new EEPROM_Data_Types <byte>(5, byte.MinValue, byte.MaxValue);

            GainSlope = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), gainSlope);

            EEPROM_Data_Types <byte> redPeak = new EEPROM_Data_Types <byte>(0, byte.MinValue, byte.MaxValue);

            HotSpotRedPeak = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), redPeak);

            EEPROM_Data_Types <byte> greenPeak = new EEPROM_Data_Types <byte>(0, byte.MinValue, byte.MaxValue);

            HotSpotGreenPeak = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), greenPeak);

            EEPROM_Data_Types <byte> bluePeak = new EEPROM_Data_Types <byte>(0, byte.MinValue, byte.MaxValue);

            HotSpotBluePeak = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Byte, 1), bluePeak);


            EEPROM_Data_Types <Int16> hsRedRad = new EEPROM_Data_Types <Int16>(0, 0, 1000);

            HotSpotRedRadius = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 1), hsRedRad);

            EEPROM_Data_Types <Int16> hsGreenRad = new EEPROM_Data_Types <Int16>(0, 0, 1000);

            HotSpotGreenRadius = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 1), hsGreenRad);

            EEPROM_Data_Types <Int16> hsBlueRad = new EEPROM_Data_Types <Int16>(0, 0, 1000);

            HotSpotBlueRadius = EEPROM_Props.CreateIVLProperties(EEPROM_Type_Info.CreateEEPROM_TypeInfo(DataTypes.Int16, 1), hsBlueRad);
        }