←Select platform

GetEnumMemberFriendlyNames Method

Summary
Gets an array of strings containing the enumeration members friendly names.
Syntax
C#
Objective-C
C++/CLI
Java
Python
public string[] GetEnumMemberFriendlyNames() 
@property (nonatomic, copy, readonly, nullable) NSArray<NSString *> *enumMemberFriendlyNames; 
public ArrayList<String> getEnumMemberFriendlyNames() 
array<String^>^ GetEnumMemberFriendlyNames();  
def GetEnumMemberFriendlyNames(self): 

Return Value

An array of strings containing the enumeration members friendly names.

Remarks

If the enum members can be OR'ed together, you can OR multiple members obtained from GetEnumMemberValues or GetEnumMemberFriendlyNames into one integer or string value (separated by a comma) and pass them as the setting value. This is the same as having an enum in .NET decorated with the FlagsAttribute.

If the enum members cannot be OR'ed together (The value of EnumIsFlags is false), then only one member obtained from GetEnumMemberValues or GetEnumMemberFriendlyNames can used as the setting value. This the same as having an enum in .NET not decorated with the FlagsAttribute.

This member is only valid if ValueType is OcrSettingValueType.Enum.

For a list of supported engine-specific settings and their meanings, refer to OCR engine-specific Settings.

Example
C#
using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.Ocr; 
using Leadtools.Document.Writer; 
 
public void OcrSettingManagerExample() 
{ 
   // Create an instance of the engine 
   using (IOcrEngine ocrEngine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD)) 
   { 
      // Start the engine using default parameters 
      ocrEngine.Startup(null, null, null, LEAD_VARS.OcrLEADRuntimeDir); 
 
      IOcrSettingManager settingManager = ocrEngine.SettingManager; 
 
      // Dump all the settings supported by this engine to a text file on disk 
      DumpAllSettings(settingManager); 
 
      // Image file to OCR 
      string tifFileName = Path.Combine(LEAD_VARS.ImagesDir, "Ocr1.tif"); 
 
      // File formats to save 
      DocumentFormat[] formats = { DocumentFormat.Text, DocumentFormat.Pdf }; 
 
      foreach (DocumentFormat format in formats) 
      { 
         // Generate the output file name 
         string outFileName = Path.ChangeExtension(tifFileName, DocumentWriter.GetFormatFileExtension(format)); 
 
         Console.WriteLine("Format: {0}\nOutput file: {1}", format, outFileName); 
 
         int detectFontStyles = 0; 
         bool recognizeFontAttributes = false; 
 
         if (format == DocumentFormat.Text) 
         { 
            // This is 'text' format, we dont need to recognize fonts attributes such as bold and italic 
            // This will make the recognition process faster 
 
            Console.WriteLine("Turning off font attributes"); 
 
            // Save the old settings 
            detectFontStyles = settingManager.GetEnumValue("Recognition.Fonts.DetectFontStyles"); 
            recognizeFontAttributes = settingManager.GetBooleanValue("Recognition.Fonts.RecognizeFontAttributes"); 
 
            // Turn them off now 
            settingManager.SetEnumValue("Recognition.Fonts.DetectFontStyles", "None"); 
            settingManager.SetBooleanValue("Recognition.Fonts.RecognizeFontAttributes", false); 
         } 
 
         // Show the settings we are using 
         Console.WriteLine("Recognizing using these font attributes settings:"); 
         Console.WriteLine("Recognition.Fonts.DetectFontStyles: {0}", settingManager.GetEnumValueAsString("Recognition.Fonts.DetectFontStyles")); 
         Console.WriteLine("Recognition.Fonts.RecognizeFontAttributes: {0}", settingManager.GetBooleanValue("Recognition.Fonts.RecognizeFontAttributes")); 
 
 
         // Recognize and save the file to the output format 
         using (IOcrDocument ocrDocument = ocrEngine.DocumentManager.CreateDocument()) 
         { 
            // Add a page to the document 
            IOcrPage ocrPage = ocrDocument.Pages.AddPage(tifFileName, null); 
 
            // Recognize the page 
            // Note, Recognize can be called without calling AutoZone or manually adding zones. The engine will 
            // check and automatically auto-zones the page 
            ocrPage.Recognize(null); 
 
            // Save the document we have as PDF 
            ocrDocument.Save(outFileName, format, null); 
         } 
 
         // Re-set the original settings 
         if (format == DocumentFormat.Text) 
         { 
            Console.WriteLine("Resetting original settings"); 
            settingManager.SetEnumValue("Recognition.Fonts.DetectFontStyles", detectFontStyles); 
            settingManager.SetBooleanValue("Recognition.Fonts.RecognizeFontAttributes", recognizeFontAttributes); 
         } 
      } 
 
      // Shutdown the engine 
      // Note: calling Dispose will also automatically shutdown the engine if it has been started 
      ocrEngine.Shutdown(); 
   } 
} 
 
private static void DumpAllSettings(IOcrSettingManager settingManager) 
{ 
   // Write all the settings into a disk file 
   string settingsFileName = Path.Combine(LEAD_VARS.ImagesDir, "Settings.txt"); 
   using (StreamWriter writer = File.CreateText(settingsFileName)) 
   { 
      writer.WriteLine("Settings"); 
      string[] settingNames = settingManager.GetSettingNames(); 
 
      foreach (string settingName in settingNames) 
      { 
         IOcrSettingDescriptor sd = settingManager.GetSettingDescriptor(settingName); 
 
         writer.WriteLine("  Name:           {0}", sd.Name); 
         writer.WriteLine("  ValueType:      {0}", sd.ValueType); 
         writer.WriteLine("  FriendlyName:   {0}", sd.FriendlyName); 
 
         switch (sd.ValueType) 
         { 
            case OcrSettingValueType.BeginCategory: 
               writer.WriteLine("-------------------------------------"); 
               break; 
 
            case OcrSettingValueType.Integer: 
               writer.WriteLine("    Units: {0}", sd.Units); 
               writer.WriteLine("    IntegerMinimumValue: {0}", sd.IntegerMinimumValue); 
               writer.WriteLine("    IntegerMaximumValue: {0}", sd.IntegerMaximumValue); 
               break; 
 
            case OcrSettingValueType.Enum: 
               writer.WriteLine("    EnumIsFlags: {0}", sd.EnumIsFlags); 
               writer.WriteLine("    EnumMemberFriendlyNames"); 
               { 
                  int[] values = sd.GetEnumMemberValues(); 
                  string[] names = sd.GetEnumMemberFriendlyNames(); 
                  for (int i = 0; i < values.Length; i++) 
                  { 
                     writer.WriteLine("      {0} : {1}", names[i], values[i]); 
                  } 
               } 
               break; 
 
            case OcrSettingValueType.Double: 
               writer.WriteLine("    Units: {0}", sd.Units); 
               writer.WriteLine("    DoubleMinimumValue: {0}", sd.DoubleMinimumValue); 
               writer.WriteLine("    DoubleMaximumValue: {0}", sd.DoubleMaximumValue); 
               break; 
 
            case OcrSettingValueType.Boolean: 
               break; 
 
            case OcrSettingValueType.Character: 
               break; 
 
            case OcrSettingValueType.String: 
               writer.WriteLine("    StringMaximumLength:   {0}", sd.StringMaximumLength); 
               writer.WriteLine("    StringNullAllowed:     {0}", sd.StringNullAllowed); 
               break; 
 
            case OcrSettingValueType.Rectangle: 
               break; 
 
            case OcrSettingValueType.EndCategory: 
               break; 
 
            default: 
               break; 
         } 
      } 
   } 
} 
 
static class LEAD_VARS 
{ 
   public const string ImagesDir = @"C:\LEADTOOLS23\Resources\Images"; 
   public const string OcrLEADRuntimeDir = @"C:\LEADTOOLS23\Bin\Common\OcrLEADRuntime"; 
} 
Requirements

Target Platforms

Help Version 23.0.2024.4.19
Products | Support | Contact Us | Intellectual Property Notices
© 1991-2024 LEAD Technologies, Inc. All Rights Reserved.

Leadtools.Ocr Assembly
Products | Support | Contact Us | Intellectual Property Notices
© 1991-2023 LEAD Technologies, Inc. All Rights Reserved.