XplorePlane/XP.ImageProcessing.Processors/Resources/Resources.Designer.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     此代码由工具生成。
//     运行时版本:4.0.30319.42000
//
//     对此文件的更改可能会导致不正确的行为，并且如果
//     重新生成代码，这些更改将会丢失。
// </auto-generated>
//------------------------------------------------------------------------------

namespace XP.ImageProcessing.Processors.Resources {
    using System;
    
    
    /// <summary>
    ///   一个强类型的资源类，用于查找本地化的字符串等。
    /// </summary>
    // 此类是由 StronglyTypedResourceBuilder
    // 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。
    // 若要添加或移除成员，请编辑 .ResX 文件，然后重新运行 ResGen
    // (以 /str 作为命令选项)，或重新生成 VS 项目。
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <summary>
        ///   返回此类使用的缓存的 ResourceManager 实例。
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("XP.ImageProcessing.Processors.Resources.Resources", typeof(Resources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   重写当前线程的 CurrentUICulture 属性，对
        ///   使用此强类型资源类的所有资源查找执行重写。
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   查找类似 Preserve image information within specified frequency range 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_Description {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Filter Type 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_FilterType {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_FilterType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Transition characteristics of the filter 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_FilterType_Desc {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_FilterType_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 High Cutoff Radius 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_HighCutoff {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_HighCutoff", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Components above this frequency will be removed 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_HighCutoff_Desc {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_HighCutoff_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Low Cutoff Radius 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_LowCutoff {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_LowCutoff", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Components below this frequency will be removed 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_LowCutoff_Desc {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_LowCutoff_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Band Pass Filter 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_Name {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Butterworth Order 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_Order {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_Order", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Order of Butterworth filter 的本地化字符串。
        /// </summary>
        public static string BandPassFilterProcessor_Order_Desc {
            get {
                return ResourceManager.GetString("BandPassFilterProcessor_Order_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge-preserving smoothing filter 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_Description {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Diameter 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_Diameter {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_Diameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Diameter of each pixel neighborhood 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_Diameter_Desc {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_Diameter_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Bilateral Filter 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_Name {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sigma Color 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_SigmaColor {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_SigmaColor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Filter sigma in the color space 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_SigmaColor_Desc {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_SigmaColor_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sigma Space 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_SigmaSpace {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_SigmaSpace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Filter sigma in the coordinate space 的本地化字符串。
        /// </summary>
        public static string BilateralFilterProcessor_SigmaSpace_Desc {
            get {
                return ResourceManager.GetString("BilateralFilterProcessor_SigmaSpace_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detect contours in image and output contour information 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_Description {
            get {
                return ResourceManager.GetString("ContourProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Max Area 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_MaxArea {
            get {
                return ResourceManager.GetString("ContourProcessor_MaxArea", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Filter contours larger than this area 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_MaxArea_Desc {
            get {
                return ResourceManager.GetString("ContourProcessor_MaxArea_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Min Area 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_MinArea {
            get {
                return ResourceManager.GetString("ContourProcessor_MinArea", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Filter contours smaller than this area 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_MinArea_Desc {
            get {
                return ResourceManager.GetString("ContourProcessor_MinArea_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Contour Detection 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_Name {
            get {
                return ResourceManager.GetString("ContourProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Target Color 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_TargetColor {
            get {
                return ResourceManager.GetString("ContourProcessor_TargetColor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select the color of regions to find (white or black) 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_TargetColor_Desc {
            get {
                return ResourceManager.GetString("ContourProcessor_TargetColor_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Line Thickness 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_Thickness {
            get {
                return ResourceManager.GetString("ContourProcessor_Thickness", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Thickness of contour lines 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_Thickness_Desc {
            get {
                return ResourceManager.GetString("ContourProcessor_Thickness_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Threshold Value 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_ThresholdValue {
            get {
                return ResourceManager.GetString("ContourProcessor_ThresholdValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Threshold value for binarization (0-255) 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_ThresholdValue_Desc {
            get {
                return ResourceManager.GetString("ContourProcessor_ThresholdValue_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Use Otsu Auto Threshold 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_UseOtsu {
            get {
                return ResourceManager.GetString("ContourProcessor_UseOtsu", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Automatically calculate optimal threshold 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_UseOtsu_Desc {
            get {
                return ResourceManager.GetString("ContourProcessor_UseOtsu_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Enable Threshold 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_UseThreshold {
            get {
                return ResourceManager.GetString("ContourProcessor_UseThreshold", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Apply binary threshold before contour detection 的本地化字符串。
        /// </summary>
        public static string ContourProcessor_UseThreshold_Desc {
            get {
                return ResourceManager.GetString("ContourProcessor_UseThreshold_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Auto Contrast 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_AutoContrast {
            get {
                return ResourceManager.GetString("ContrastProcessor_AutoContrast", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Automatically stretch contrast to full range 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_AutoContrast_Desc {
            get {
                return ResourceManager.GetString("ContrastProcessor_AutoContrast_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Brightness 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_Brightness {
            get {
                return ResourceManager.GetString("ContrastProcessor_Brightness", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Brightness offset 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_Brightness_Desc {
            get {
                return ResourceManager.GetString("ContrastProcessor_Brightness_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 CLAHE Clip Limit 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_ClipLimit {
            get {
                return ResourceManager.GetString("ContrastProcessor_ClipLimit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 CLAHE contrast limit threshold 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_ClipLimit_Desc {
            get {
                return ResourceManager.GetString("ContrastProcessor_ClipLimit_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Contrast 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_Contrast {
            get {
                return ResourceManager.GetString("ContrastProcessor_Contrast", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Contrast gain, 1.0 for original contrast 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_Contrast_Desc {
            get {
                return ResourceManager.GetString("ContrastProcessor_Contrast_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Adjust image contrast and brightness 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_Description {
            get {
                return ResourceManager.GetString("ContrastProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Contrast Adjustment 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_Name {
            get {
                return ResourceManager.GetString("ContrastProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Use CLAHE 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_UseCLAHE {
            get {
                return ResourceManager.GetString("ContrastProcessor_UseCLAHE", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Use Contrast Limited Adaptive Histogram Equalization 的本地化字符串。
        /// </summary>
        public static string ContrastProcessor_UseCLAHE_Desc {
            get {
                return ResourceManager.GetString("ContrastProcessor_UseCLAHE_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Perform division operation on image for background correction and normalization 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Description {
            get {
                return ResourceManager.GetString("DivisionProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Divisor 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Divisor {
            get {
                return ResourceManager.GetString("DivisionProcessor_Divisor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Each pixel value will be divided by this number 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Divisor_Desc {
            get {
                return ResourceManager.GetString("DivisionProcessor_Divisor_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Division Operation 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Name {
            get {
                return ResourceManager.GetString("DivisionProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Normalize Output 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Normalize {
            get {
                return ResourceManager.GetString("DivisionProcessor_Normalize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Normalize result to 0-255 range 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Normalize_Desc {
            get {
                return ResourceManager.GetString("DivisionProcessor_Normalize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale Factor 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Scale {
            get {
                return ResourceManager.GetString("DivisionProcessor_Scale", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Division result multiplied by this scale factor 的本地化字符串。
        /// </summary>
        public static string DivisionProcessor_Scale_Desc {
            get {
                return ResourceManager.GetString("DivisionProcessor_Scale_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Preserve image information within specified frequency range 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_BandPass_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_BandPass_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Band Pass Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_BandPass_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_BandPass_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Band Pass Filter Type 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_BandPassFilterType {
            get {
                return ResourceManager.GetString("FilterProcessor_BandPassFilterType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Transition characteristics of the band pass filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_BandPassFilterType_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_BandPassFilterType_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge-preserving smoothing filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Bilateral_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_Bilateral_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Bilateral Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Bilateral_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_Bilateral_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Cutoff Frequency 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_D0 {
            get {
                return ResourceManager.GetString("FilterProcessor_D0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Cutoff frequency for frequency domain filtering 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_D0_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_D0_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Integrated multiple filtering methods 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Description {
            get {
                return ResourceManager.GetString("FilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Filter Type 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_FilterType {
            get {
                return ResourceManager.GetString("FilterProcessor_FilterType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select filtering method 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_FilterType_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_FilterType_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Smooth image and reduce Gaussian noise while preserving edges 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Gaussian_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_Gaussian_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gaussian Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Gaussian_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_Gaussian_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 High Cutoff Radius 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_HighCutoff {
            get {
                return ResourceManager.GetString("FilterProcessor_HighCutoff", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Components above this frequency will be removed 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_HighCutoff_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_HighCutoff_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge enhancement in frequency domain 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_HighPass_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_HighPass_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 High Pass Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_HighPass_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_HighPass_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kernel Size 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_KernelSize {
            get {
                return ResourceManager.GetString("FilterProcessor_KernelSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Size of the filter kernel (must be odd) 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_KernelSize_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_KernelSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Low Cutoff Radius 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_LowCutoff {
            get {
                return ResourceManager.GetString("FilterProcessor_LowCutoff", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Components below this frequency will be removed 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_LowCutoff_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_LowCutoff_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Remove high frequency noise in frequency domain 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_LowPass_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_LowPass_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Low Pass Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_LowPass_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_LowPass_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Simple averaging smoothing filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Mean_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_Mean_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Mean Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Mean_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_Mean_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Remove salt-and-pepper noise effectively 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Median_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_Median_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Median Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Median_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_Median_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Comprehensive Filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Name {
            get {
                return ResourceManager.GetString("FilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Butterworth Order 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Order {
            get {
                return ResourceManager.GetString("FilterProcessor_Order", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Order of Butterworth filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Order_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_Order_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sigma 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Sigma {
            get {
                return ResourceManager.GetString("FilterProcessor_Sigma", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Standard deviation for Gaussian/Bilateral filter 的本地化字符串。
        /// </summary>
        public static string FilterProcessor_Sigma_Desc {
            get {
                return ResourceManager.GetString("FilterProcessor_Sigma_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Adjust image brightness through Gamma value 的本地化字符串。
        /// </summary>
        public static string GammaProcessor_Description {
            get {
                return ResourceManager.GetString("GammaProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gain 的本地化字符串。
        /// </summary>
        public static string GammaProcessor_Gain {
            get {
                return ResourceManager.GetString("GammaProcessor_Gain", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Output gain coefficient 的本地化字符串。
        /// </summary>
        public static string GammaProcessor_Gain_Desc {
            get {
                return ResourceManager.GetString("GammaProcessor_Gain_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gamma Value 的本地化字符串。
        /// </summary>
        public static string GammaProcessor_Gamma {
            get {
                return ResourceManager.GetString("GammaProcessor_Gamma", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gamma value, less than 1 darkens image, greater than 1 brightens image 的本地化字符串。
        /// </summary>
        public static string GammaProcessor_Gamma_Desc {
            get {
                return ResourceManager.GetString("GammaProcessor_Gamma_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gamma Correction 的本地化字符串。
        /// </summary>
        public static string GammaProcessor_Name {
            get {
                return ResourceManager.GetString("GammaProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Smooth image using Gaussian kernel 的本地化字符串。
        /// </summary>
        public static string GaussianBlurProcessor_Description {
            get {
                return ResourceManager.GetString("GaussianBlurProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kernel Size 的本地化字符串。
        /// </summary>
        public static string GaussianBlurProcessor_KernelSize {
            get {
                return ResourceManager.GetString("GaussianBlurProcessor_KernelSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Size of Gaussian kernel, must be odd 的本地化字符串。
        /// </summary>
        public static string GaussianBlurProcessor_KernelSize_Desc {
            get {
                return ResourceManager.GetString("GaussianBlurProcessor_KernelSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gaussian Blur 的本地化字符串。
        /// </summary>
        public static string GaussianBlurProcessor_Name {
            get {
                return ResourceManager.GetString("GaussianBlurProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Standard Deviation 的本地化字符串。
        /// </summary>
        public static string GaussianBlurProcessor_Sigma {
            get {
                return ResourceManager.GetString("GaussianBlurProcessor_Sigma", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Standard deviation of Gaussian kernel, controls blur amount 的本地化字符串。
        /// </summary>
        public static string GaussianBlurProcessor_Sigma_Desc {
            get {
                return ResourceManager.GetString("GaussianBlurProcessor_Sigma_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Convert image to grayscale 的本地化字符串。
        /// </summary>
        public static string GrayscaleProcessor_Description {
            get {
                return ResourceManager.GetString("GrayscaleProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Conversion Method 的本地化字符串。
        /// </summary>
        public static string GrayscaleProcessor_Method {
            get {
                return ResourceManager.GetString("GrayscaleProcessor_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Method for grayscale conversion 的本地化字符串。
        /// </summary>
        public static string GrayscaleProcessor_Method_Desc {
            get {
                return ResourceManager.GetString("GrayscaleProcessor_Method_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Grayscale Conversion 的本地化字符串。
        /// </summary>
        public static string GrayscaleProcessor_Name {
            get {
                return ResourceManager.GetString("GrayscaleProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Bias 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Bias {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Bias", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Bias for adaptive logarithmic and Drago mapping, controls dark/bright balance 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Bias_Desc {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Bias_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 High Dynamic Range image enhancement with tone mapping 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Description {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detail Boost 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_DetailBoost {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_DetailBoost", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detail enhancement factor, higher values reveal more fine details 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_DetailBoost_Desc {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_DetailBoost_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gamma 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Gamma {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Gamma", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gamma correction value for output brightness adjustment 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Gamma_Desc {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Gamma_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Tone Mapping Method 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Method {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select HDR tone mapping algorithm: LocalToneMap, AdaptiveLog, Drago, BilateralToneMap 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Method_Desc {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Method_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 HDR Enhancement 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Name {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Saturation 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Saturation {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Saturation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Contrast saturation factor for LocalToneMap method 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_Saturation_Desc {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_Saturation_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sigma Color 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_SigmaColor {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_SigmaColor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Color sigma for bilateral tone mapping, controls edge preservation 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_SigmaColor_Desc {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_SigmaColor_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sigma Space 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_SigmaSpace {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_SigmaSpace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Spatial sigma for base layer extraction, controls smoothing range 的本地化字符串。
        /// </summary>
        public static string HDREnhancementProcessor_SigmaSpace_Desc {
            get {
                return ResourceManager.GetString("HDREnhancementProcessor_SigmaSpace_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Cutoff Frequency 的本地化字符串。
        /// </summary>
        public static string HighPassFilterProcessor_CutoffFrequency {
            get {
                return ResourceManager.GetString("HighPassFilterProcessor_CutoffFrequency", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Cutoff frequency for high pass filter 的本地化字符串。
        /// </summary>
        public static string HighPassFilterProcessor_CutoffFrequency_Desc {
            get {
                return ResourceManager.GetString("HighPassFilterProcessor_CutoffFrequency_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge enhancement in frequency domain 的本地化字符串。
        /// </summary>
        public static string HighPassFilterProcessor_Description {
            get {
                return ResourceManager.GetString("HighPassFilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 High Pass Filter 的本地化字符串。
        /// </summary>
        public static string HighPassFilterProcessor_Name {
            get {
                return ResourceManager.GetString("HighPassFilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Clip Limit 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_ClipLimit {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_ClipLimit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Contrast limiting threshold for CLAHE 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_ClipLimit_Desc {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_ClipLimit_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Enhance image contrast 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_Description {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Equalization Method 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_Method {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select histogram equalization algorithm 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_Method_Desc {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_Method_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Histogram Equalization 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_Name {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Tile Size 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_TileSize {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_TileSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Tile size for CLAHE 的本地化字符串。
        /// </summary>
        public static string HistogramEqualizationProcessor_TileSize_Desc {
            get {
                return ResourceManager.GetString("HistogramEqualizationProcessor_TileSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detect horizontal edges specifically 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Description {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detection Method 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Method {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select horizontal edge detection algorithm 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Method_Desc {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Method_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Horizontal Edge Detection 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Name {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sensitivity 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Sensitivity {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Sensitivity", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge detection sensitivity 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Sensitivity_Desc {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Sensitivity_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Threshold 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Threshold {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Threshold", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge detection threshold 的本地化字符串。
        /// </summary>
        public static string HorizontalEdgeProcessor_Threshold_Desc {
            get {
                return ResourceManager.GetString("HorizontalEdgeProcessor_Threshold_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detect image edges using Kirsch operator 的本地化字符串。
        /// </summary>
        public static string KirschEdgeProcessor_Description {
            get {
                return ResourceManager.GetString("KirschEdgeProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kirsch Edge Detection 的本地化字符串。
        /// </summary>
        public static string KirschEdgeProcessor_Name {
            get {
                return ResourceManager.GetString("KirschEdgeProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale Factor 的本地化字符串。
        /// </summary>
        public static string KirschEdgeProcessor_Scale {
            get {
                return ResourceManager.GetString("KirschEdgeProcessor_Scale", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale factor for edge intensity 的本地化字符串。
        /// </summary>
        public static string KirschEdgeProcessor_Scale_Desc {
            get {
                return ResourceManager.GetString("KirschEdgeProcessor_Scale_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Threshold 的本地化字符串。
        /// </summary>
        public static string KirschEdgeProcessor_Threshold {
            get {
                return ResourceManager.GetString("KirschEdgeProcessor_Threshold", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge detection threshold 的本地化字符串。
        /// </summary>
        public static string KirschEdgeProcessor_Threshold_Desc {
            get {
                return ResourceManager.GetString("KirschEdgeProcessor_Threshold_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Cutoff Frequency 的本地化字符串。
        /// </summary>
        public static string LowPassFilterProcessor_CutoffFrequency {
            get {
                return ResourceManager.GetString("LowPassFilterProcessor_CutoffFrequency", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Cutoff frequency for low pass filter 的本地化字符串。
        /// </summary>
        public static string LowPassFilterProcessor_CutoffFrequency_Desc {
            get {
                return ResourceManager.GetString("LowPassFilterProcessor_CutoffFrequency_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Remove high frequency noise in frequency domain 的本地化字符串。
        /// </summary>
        public static string LowPassFilterProcessor_Description {
            get {
                return ResourceManager.GetString("LowPassFilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Low Pass Filter 的本地化字符串。
        /// </summary>
        public static string LowPassFilterProcessor_Name {
            get {
                return ResourceManager.GetString("LowPassFilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Simple averaging smoothing filter 的本地化字符串。
        /// </summary>
        public static string MeanFilterProcessor_Description {
            get {
                return ResourceManager.GetString("MeanFilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kernel Size 的本地化字符串。
        /// </summary>
        public static string MeanFilterProcessor_KernelSize {
            get {
                return ResourceManager.GetString("MeanFilterProcessor_KernelSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Size of the filter kernel (must be odd) 的本地化字符串。
        /// </summary>
        public static string MeanFilterProcessor_KernelSize_Desc {
            get {
                return ResourceManager.GetString("MeanFilterProcessor_KernelSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Mean Filter 的本地化字符串。
        /// </summary>
        public static string MeanFilterProcessor_Name {
            get {
                return ResourceManager.GetString("MeanFilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Remove salt-and-pepper noise effectively 的本地化字符串。
        /// </summary>
        public static string MedianFilterProcessor_Description {
            get {
                return ResourceManager.GetString("MedianFilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kernel Size 的本地化字符串。
        /// </summary>
        public static string MedianFilterProcessor_KernelSize {
            get {
                return ResourceManager.GetString("MedianFilterProcessor_KernelSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Size of the filter kernel (must be odd) 的本地化字符串。
        /// </summary>
        public static string MedianFilterProcessor_KernelSize_Desc {
            get {
                return ResourceManager.GetString("MedianFilterProcessor_KernelSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Median Filter 的本地化字符串。
        /// </summary>
        public static string MedianFilterProcessor_Name {
            get {
                return ResourceManager.GetString("MedianFilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Flip image horizontally, vertically, or both 的本地化字符串。
        /// </summary>
        public static string MirrorProcessor_Description {
            get {
                return ResourceManager.GetString("MirrorProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Direction 的本地化字符串。
        /// </summary>
        public static string MirrorProcessor_Direction {
            get {
                return ResourceManager.GetString("MirrorProcessor_Direction", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Flip direction: Horizontal (left-right), Vertical (up-down), Both (180° rotation) 的本地化字符串。
        /// </summary>
        public static string MirrorProcessor_Direction_Desc {
            get {
                return ResourceManager.GetString("MirrorProcessor_Direction_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Mirror 的本地化字符串。
        /// </summary>
        public static string MirrorProcessor_Name {
            get {
                return ResourceManager.GetString("MirrorProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Perform morphological operations (erosion, dilation, opening, closing) 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_Description {
            get {
                return ResourceManager.GetString("MorphologyProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Iterations 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_Iterations {
            get {
                return ResourceManager.GetString("MorphologyProcessor_Iterations", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Number of times to repeat morphological operation 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_Iterations_Desc {
            get {
                return ResourceManager.GetString("MorphologyProcessor_Iterations_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kernel Size 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_KernelSize {
            get {
                return ResourceManager.GetString("MorphologyProcessor_KernelSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Size of structuring element 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_KernelSize_Desc {
            get {
                return ResourceManager.GetString("MorphologyProcessor_KernelSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Morphology Processing 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_Name {
            get {
                return ResourceManager.GetString("MorphologyProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Operation Type 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_Operation {
            get {
                return ResourceManager.GetString("MorphologyProcessor_Operation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select morphological operation type 的本地化字符串。
        /// </summary>
        public static string MorphologyProcessor_Operation_Desc {
            get {
                return ResourceManager.GetString("MorphologyProcessor_Operation_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Color Map 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_ColorMap {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_ColorMap", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select color mapping table for rendering 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_ColorMap_Desc {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_ColorMap_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Map grayscale image to color image using color maps 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_Description {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Invert Color Map 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_InvertMap {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_InvertMap", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Reverse the color mapping direction 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_InvertMap_Desc {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_InvertMap_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Max Gray Value 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_MaxValue {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_MaxValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gray values above this will be clipped to maximum color 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_MaxValue_Desc {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_MaxValue_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Min Gray Value 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_MinValue {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_MinValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gray values below this will be clipped to minimum color 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_MinValue_Desc {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_MinValue_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Pseudo Color Rendering 的本地化字符串。
        /// </summary>
        public static string PseudoColorProcessor_Name {
            get {
                return ResourceManager.GetString("PseudoColorProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Multi-scale shadow correction and illumination equalization based on Retinex 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Description {
            get {
                return ResourceManager.GetString("RetinexProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Gain 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Gain {
            get {
                return ResourceManager.GetString("RetinexProcessor_Gain", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Output gain factor 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Gain_Desc {
            get {
                return ResourceManager.GetString("RetinexProcessor_Gain_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Processing Method 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Method {
            get {
                return ResourceManager.GetString("RetinexProcessor_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select Retinex algorithm type 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Method_Desc {
            get {
                return ResourceManager.GetString("RetinexProcessor_Method_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Retinex Shadow Correction 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Name {
            get {
                return ResourceManager.GetString("RetinexProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Offset 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Offset {
            get {
                return ResourceManager.GetString("RetinexProcessor_Offset", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Output offset value 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Offset_Desc {
            get {
                return ResourceManager.GetString("RetinexProcessor_Offset_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale 1 (Small) 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Sigma1 {
            get {
                return ResourceManager.GetString("RetinexProcessor_Sigma1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Small scale Gaussian kernel sigma for detail enhancement 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Sigma1_Desc {
            get {
                return ResourceManager.GetString("RetinexProcessor_Sigma1_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale 2 (Medium) 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Sigma2 {
            get {
                return ResourceManager.GetString("RetinexProcessor_Sigma2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Medium scale Gaussian kernel sigma for local illumination correction 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Sigma2_Desc {
            get {
                return ResourceManager.GetString("RetinexProcessor_Sigma2_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale 3 (Large) 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Sigma3 {
            get {
                return ResourceManager.GetString("RetinexProcessor_Sigma3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Large scale Gaussian kernel sigma for global illumination correction 的本地化字符串。
        /// </summary>
        public static string RetinexProcessor_Sigma3_Desc {
            get {
                return ResourceManager.GetString("RetinexProcessor_Sigma3_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Angle 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_Angle {
            get {
                return ResourceManager.GetString("RotateProcessor_Angle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Rotation angle in degrees, positive is counter-clockwise 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_Angle_Desc {
            get {
                return ResourceManager.GetString("RotateProcessor_Angle_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Background 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_BackgroundValue {
            get {
                return ResourceManager.GetString("RotateProcessor_BackgroundValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Background fill value (0-255) for areas outside the original image 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_BackgroundValue_Desc {
            get {
                return ResourceManager.GetString("RotateProcessor_BackgroundValue_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Rotate image by arbitrary angle with optional canvas expansion 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_Description {
            get {
                return ResourceManager.GetString("RotateProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Expand Canvas 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_ExpandCanvas {
            get {
                return ResourceManager.GetString("RotateProcessor_ExpandCanvas", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Expand canvas to fit the entire rotated image, otherwise crop to original size 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_ExpandCanvas_Desc {
            get {
                return ResourceManager.GetString("RotateProcessor_ExpandCanvas_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Interpolation 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_Interpolation {
            get {
                return ResourceManager.GetString("RotateProcessor_Interpolation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Interpolation method: Nearest (fast), Bilinear (smooth), Bicubic (high quality) 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_Interpolation_Desc {
            get {
                return ResourceManager.GetString("RotateProcessor_Interpolation_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Rotate 的本地化字符串。
        /// </summary>
        public static string RotateProcessor_Name {
            get {
                return ResourceManager.GetString("RotateProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Enhance image edges and details 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_Description {
            get {
                return ResourceManager.GetString("SharpenProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kernel Size 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_KernelSize {
            get {
                return ResourceManager.GetString("SharpenProcessor_KernelSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Size of sharpening kernel (must be odd) 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_KernelSize_Desc {
            get {
                return ResourceManager.GetString("SharpenProcessor_KernelSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sharpen Method 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_Method {
            get {
                return ResourceManager.GetString("SharpenProcessor_Method", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select sharpening algorithm 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_Method_Desc {
            get {
                return ResourceManager.GetString("SharpenProcessor_Method_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sharpen 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_Name {
            get {
                return ResourceManager.GetString("SharpenProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Strength 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_Strength {
            get {
                return ResourceManager.GetString("SharpenProcessor_Strength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Strength of sharpening effect 的本地化字符串。
        /// </summary>
        public static string SharpenProcessor_Strength_Desc {
            get {
                return ResourceManager.GetString("SharpenProcessor_Strength_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge enhancement and denoising 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Description {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Time Step 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Dt {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Dt", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Evolution time step 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Dt_Desc {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Dt_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Iterations 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Iterations {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Iterations", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Number of filter iterations 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Iterations_Desc {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Iterations_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Shock Filter 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Name {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Threshold 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Theta {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Theta", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Edge detection threshold 的本地化字符串。
        /// </summary>
        public static string ShockFilterProcessor_Theta_Desc {
            get {
                return ResourceManager.GetString("ShockFilterProcessor_Theta_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detect image edges using Sobel operator 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_Description {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Detection Direction 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_Direction {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_Direction", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Select edge detection direction 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_Direction_Desc {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_Direction_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Kernel Size 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_KernelSize {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_KernelSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sobel operator kernel size (odd number) 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_KernelSize_Desc {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_KernelSize_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Sobel Edge Detection 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_Name {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale Factor 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_Scale {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_Scale", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Scale factor for edge intensity 的本地化字符串。
        /// </summary>
        public static string SobelEdgeProcessor_Scale_Desc {
            get {
                return ResourceManager.GetString("SobelEdgeProcessor_Scale_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Binarize image 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_Description {
            get {
                return ResourceManager.GetString("ThresholdProcessor_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Max Value 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_MaxValue {
            get {
                return ResourceManager.GetString("ThresholdProcessor_MaxValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Pixels above threshold will be set to this value 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_MaxValue_Desc {
            get {
                return ResourceManager.GetString("ThresholdProcessor_MaxValue_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Threshold Segmentation 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_Name {
            get {
                return ResourceManager.GetString("ThresholdProcessor_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Threshold 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_Threshold {
            get {
                return ResourceManager.GetString("ThresholdProcessor_Threshold", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Binarization threshold, pixels above this value will be set to max value 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_Threshold_Desc {
            get {
                return ResourceManager.GetString("ThresholdProcessor_Threshold_Desc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 Use Otsu Auto Threshold 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_UseOtsu {
            get {
                return ResourceManager.GetString("ThresholdProcessor_UseOtsu", resourceCulture);
            }
        }
        
        /// <summary>
        ///   查找类似 When enabled, optimal threshold will be calculated automatically 的本地化字符串。
        /// </summary>
        public static string ThresholdProcessor_UseOtsu_Desc {
            get {
                return ResourceManager.GetString("ThresholdProcessor_UseOtsu_Desc", resourceCulture);
            }
        }
    }
}