> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Extracción de texto

> Extraiga el cuerpo del texto de un documento con ABBYY FineReader Engine en orden natural de lectura, listo para enviarlo a motores de NLP para resumirlo, realizar búsquedas o analizar el sentimiento.

Este escenario permite extraer el cuerpo del texto de un documento y los textos presentes en logotipos, sellos y cualquier otro elemento distinto del cuerpo del texto.

Se conserva el orden natural del texto, "como lo leería una persona". Luego puede enviar los documentos a motores de procesamiento de lenguaje natural (NLP) de su entorno, por ejemplo, para resumirlos rápidamente, buscar información confidencial o someterlos a un análisis de sentimiento.

Para extraer el texto principal del documento, los archivos de imagen obtenidos mediante escaneo o guardados en formato electrónico suelen pasar por varias etapas de procesamiento, cada una con sus propias particularidades:

1. Preprocesamiento de las imágenes escaneadas o fotografías

   Las imágenes escaneadas pueden requerir cierto preprocesamiento antes del reconocimiento; por ejemplo, si los documentos escaneados contienen ruido de fondo, texto inclinado, colores invertidos, márgenes negros, orientación incorrecta o una resolución inadecuada.

2. Reconocimiento de la mayor cantidad posible de texto en una imagen de documento

   El reconocimiento de imágenes se realiza con configuraciones que garantizan que se encuentre y extraiga todo el texto posible de una imagen de documento.

<div id="scenario-implementation">
  ## Implementación del escenario
</div>

<Note>
  Los ejemplos de código proporcionados en esta sección son específicos de Windows.
</Note>

A continuación, se ofrece una descripción detallada del método recomendado para utilizar ABBYY FineReader Engine 12 en este escenario. El método propuesto emplea la configuración de procesamiento más adecuada para este caso.

<Accordion title="Paso 1. Cargar ABBYY FineReader Engine">
  Para comenzar a trabajar con ABBYY FineReader Engine, es necesario crear el objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface). El objeto Engine es el objeto de nivel superior en la jerarquía de objetos de ABBYY FineReader Engine y proporciona diversas configuraciones globales, algunos métodos de procesamiento y métodos para crear los demás objetos.

  Para crear el objeto Engine, puede usar la función [InitializeEngine](/es/fine-reader/engine/api-reference/functions/initializeengine-function). Consulte también [otras formas de cargar el objeto Engine](/es/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) (Win).

  ### C\#

  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      public EngineLoader()
      {
          // Inicialice estas variables con la ruta completa a FREngine.dll, su Customer Project ID,
          // y, si corresponde, la ruta al archivo de token de licencia en línea y la contraseña de la licencia en línea
          string enginePath = "";
          string customerProjectId = "";
          string licensePath = "";
          string licensePassword = "";
          // Cargar la biblioteca FREngine.dll
          dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
             
          try
          {
              if (dllHandle == IntPtr.Zero)
              {
                  throw new Exception("No se puede cargar " + enginePath);
              }
              IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
              if (initializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("No se puede encontrar la función InitializeEngine");
              }
              IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
              if (deinitializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("No se puede encontrar la función DeinitializeEngine");
              }
              IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
              if (dllCanUnloadNowPtr == IntPtr.Zero)
              {
                  throw new Exception("No se puede encontrar la función DllCanUnloadNow");
              }
              // Convertir punteros en delegados
              initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  initializeEnginePtr, typeof(InitializeEngine));
              deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  deinitializeEnginePtr, typeof(DeinitializeEngine));
              dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                  dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
              // Llamar a la función InitializeEngine
              // pasando la ruta al archivo de licencia en línea y la contraseña de la licencia en línea
              int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                  "", "", false, ref engine);
              Marshal.ThrowExceptionForHR(hresult);
          }
          catch (Exception)
          {
              // Liberar la biblioteca FREngine.dll
              engine = null;
              // Eliminar todos los objetos antes de llamar a FreeLibrary
              GC.Collect();
              GC.WaitForPendingFinalizers();
              GC.Collect();
              FreeLibrary(dllHandle);
              dllHandle = IntPtr.Zero;
              initializeEngine = null;
              deinitializeEngine = null;
              dllCanUnloadNow = null;
              throw;
          }
      }
      // Funciones de Kernel32.dll
      [DllImport("kernel32.dll")]
      private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
      private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
      [DllImport("kernel32.dll")]
      private static extern bool FreeLibrary(IntPtr hModule);
      // Funciones de FREngine.dll
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine(string customerProjectId, string licensePath, 
          string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
          ref FREngine.IEngine engine);
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DeinitializeEngine();
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DllCanUnloadNow();
      // Variables privadas
      private FREngine.IEngine engine = null;
      // Identificador de FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Inicialice estas variables con la ruta a FREngine.dll, el Customer Project ID de FineReader Engine,
  // y, si corresponde, la ruta al token de licencia en línea y la contraseña de licencia en línea
  wchar_t* FreDllPath;
  wchar_t* CustomerProjectId;
  wchar_t* LicensePath;  // si no utiliza una licencia en línea, asigne cadenas vacías a estas variables
  wchar_t* LicensePassword;
  // HANDLE de FREngine.dll
  static HMODULE libraryHandle = 0;
  // Objeto global de FineReader Engine
  FREngine::IEnginePtr Engine;
  void LoadFREngine()
  {
      if( Engine != 0 ) {
      // Ya cargado
      return;
      }
      // Primer paso: cargar FREngine.dll
      if( libraryHandle == 0 ) {
          libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
          if( libraryHandle == 0 ) {
              throw L"Error al cargar ABBYY FineReader Engine";
          }
      }
      // Segundo paso: obtener el objeto Engine
      typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, 
          BSTR, VARIANT_BOOL, FREngine::IEngine** );
      InitializeEngineFunc pInitializeEngine =
      ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" );
      if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, 
          LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) {
      UnloadFREngine();
      throw L"Error al cargar ABBYY FineReader Engine";
      }
  }
  ```
</Accordion>

<Accordion title="Paso 2. Carga de la configuración para el escenario">
  La configuración más adecuada para este escenario puede seleccionarse en ABBYY FineReader Engine mediante el método [LoadPredefinedProfile](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) del objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface). Este método recibe el nombre del perfil como parámetro de entrada. Consulte [Working with Profiles](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles) para obtener más información.

  ABBYY FineReader Engine admite 2 variantes de configuración para este escenario:

  <table><thead><tr><th><p><strong>Nombre del perfil</strong></p></th><th><p><strong>Descripción</strong></p></th></tr></thead><tbody><tr><td><p><em>TextExtraction\_Accuracy</em></p></td><td><p>La configuración se ha optimizado para maximizar la precisión:</p><ul><li>Permite detectar todo el texto de una imagen, incluidas pequeñas áreas de texto de baja calidad (no se detectan imágenes ni tablas).</li><li>No se realiza una síntesis completa de la estructura lógica de un documento.</li></ul><Warning>Este perfil no está pensado para convertir un documento a RTF, DOCX o PDF de solo texto. Para ello, utilice los perfiles de conversión de documentos.</Warning></td></tr><tr><td><p><em>TextExtraction\_Speed</em></p></td><td><p>La configuración se ha optimizado para maximizar la velocidad de procesamiento:</p><ul><li>Permite detectar todo el texto de una imagen, incluidas pequeñas áreas de texto de baja calidad (no se detectan imágenes ni tablas).</li><li>No se realiza una síntesis completa de la estructura lógica de un documento.</li><li>Se aceleran los procesos de análisis y reconocimiento de documentos.</li></ul><Warning>Este perfil no está pensado para convertir un documento a RTF, DOCX o PDF de solo texto. Para ello, utilice los perfiles de conversión de documentos.</Warning></td></tr></tbody></table>

  ### C\#

  ```csharp theme={null}
  // Cargar un perfil predefinido
  engine.LoadPredefinedProfile("TextExtraction_Accuracy");
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Cargar un perfil predefinido
  Engine->LoadPredefinedProfile( L"TextExtraction_Accuracy" );
  ```

  Si desea cambiar la configuración de procesamiento, utilice los objetos Parameter adecuados. Consulte [Optimización adicional para tareas específicas](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/text-extraction#optimization) a continuación para obtener más información.
</Accordion>

<Accordion title="Paso 3. Carga y preprocesamiento de las imágenes">
  ABBYY FineReader Engine proporciona el objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument), que permite procesar documentos de varias páginas.

  Para cargar las imágenes de un solo documento y preprocesarlas, debe crear el objeto FRDocument y agregarle imágenes. Puede hacerlo de una de las siguientes maneras:

  * Crear el objeto FRDocument mediante el método [CreateFRDocumentFromImage](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) del objeto Engine. Este método crea el objeto FRDocument y carga las imágenes desde el archivo especificado.
  * Crear el objeto FRDocument con ayuda del método [CreateFRDocument](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) del objeto Engine y, a continuación, agregar imágenes desde un archivo al objeto FRDocument creado (use el método [AddImageFile](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method), [AddImageFileWithPassword](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpassword-method) o [AddImageFileWithPasswordCallback](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpasswordcallback-method) del objeto FRDocument).

  ### C\#

  ```csharp theme={null}
  // Crear el objeto FRDocument a partir de un archivo de imagen
  FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Abrir un archivo de imagen y crear el objeto FRDocument
  FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
  ```
</Accordion>

<Accordion title="Paso 4. Reconocimiento de documentos">
  Para reconocer el documento, debe usar los métodos de análisis y reconocimiento del objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument). Este objeto proporciona toda una serie de métodos para el análisis y reconocimiento de documentos. El método más práctico, que permite realizar el análisis, el reconocimiento y la síntesis del documento con una sola llamada, es [Process](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method). Además, aprovecha de la forma más eficiente las funciones de procesamiento simultáneo de los sistemas multiprocesador y multinúcleo. No obstante, también puede ejecutar de forma secuencial el preprocesamiento, el análisis, el reconocimiento y la síntesis mediante los métodos [Preprocess](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocess-method), [Analyze](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method), [Recognize](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method) y [Synthesize](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/synthesize-method).

  ### C\#

  ```csharp theme={null}
  // Analizar, reconocer y sintetizar el documento
  // No se necesitan parámetros adicionales porque los define el perfil de procesamiento
  frDocument.Process( null );
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Analizar, reconocer y sintetizar el documento
  // Si el perfil está cargado, no necesita pasar parámetros adicionales al método de procesamiento
  frDocument->Process( 0 );
  ```
</Accordion>

<Accordion title="Paso 5. Búsqueda de información importante">
  Durante el análisis, ABBYY FineReader Engine selecciona bloques de imagen que contienen texto, tablas, imágenes, etc. Durante el reconocimiento, los bloques que contienen datos de texto se rellenan con el texto reconocido.

  En ABBYY FineReader Engine, el objeto [Layout](/es/fine-reader/engine/api-reference/layout-related-objects/layout) sirve para almacenar los bloques y el texto reconocido. En el flujo principal de procesamiento de documentos, se trabaja con el layout dentro del objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument), que representa el documento que se está procesando. Para acceder al layout de una página del documento, use la propiedad [IFRPage::Layout](/es/fine-reader/engine/api-reference/document-related-objects/frpage).

  Para buscar palabras clave, puede consultar el texto reconocido mediante el objeto [Text](/es/fine-reader/engine/api-reference/text-related-objects/text), al que se accede a través de las propiedades de los bloques de texto, tabla o código de barras.

  Los datos importantes que encuentre pueden guardarse o procesarse según sea necesario. Consulte [Optimización adicional para tareas específicas](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/text-extraction#optimization) más abajo para obtener información más detallada.
</Accordion>

<Accordion title="(Opcional) Paso 6. Exportación de documentos">
  Como alternativa, quizá desee almacenar el texto extraído en un formato fácil de consultar, como TXT, o en un formato estructurado que le permita recuperar fácilmente la información necesaria más adelante, como JSON.

  Use el método [Export](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) del objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument) con la constante [FileExportFormatEnum](/es/fine-reader/engine/api-reference/enumerations/fileexportformatenum) correspondiente como uno de los parámetros. Puede cambiar los parámetros de exportación predeterminados mediante el objeto de exportación correspondiente. Consulte [Optimización adicional para tareas específicas](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-conversion#optimization) más abajo para obtener más información.

  Cuando termine de trabajar con el objeto FRDocument, libere todos los recursos utilizados por este objeto. Use el método [IFRDocument::Close](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/close-method).

  ### C\#

  ```csharp theme={null}
  // Guardar el texto del documento reconocido en formato TXT
  frDocument.Export( "C:\\MyText.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
  // Liberar el objeto FRDocument
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Guardar el texto del documento reconocido en formato TXT
  frDocument->Export( L"C:\\MyText.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
  // Liberar el objeto FRDocument
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Paso 7. Descarga de ABBYY FineReader Engine">
  Cuando termine de trabajar con ABBYY FineReader Engine, debe descargar el objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface). Para ello, use la función exportada [DeinitializeEngine](/es/fine-reader/engine/api-reference/functions/deinitializeengine-function).

  ### C\#

  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      // Descargar FineReader Engine
      public void Dispose()
      {
          if (engine == null)
          {
              // Engine no se cargó
              return;
          }
          engine = null;
          // Eliminar todos los objetos antes de llamar a FreeLibrary
          GC.Collect();
          GC.WaitForPendingFinalizers();
          GC.Collect();
          int hresult = deinitializeEngine();
   
          hresult = dllCanUnloadNow();
          if (hresult == 0)
          {
              FreeLibrary(dllHandle);
          }
          dllHandle = IntPtr.Zero;
          initializeEngine = null;
          deinitializeEngine = null;
          dllCanUnloadNow = null;
          // lanzar la excepción después de la limpieza
          Marshal.ThrowExceptionForHR(hresult);
      }
      // Funciones de Kernel32.dll
      [DllImport("kernel32.dll")]
      private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
      private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
      [DllImport("kernel32.dll")]
      private static extern bool FreeLibrary(IntPtr hModule);
      // Funciones de FREngine.dll
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine( string customerProjectId, string LicensePath, string LicensePassword, , , , ref FREngine.IEngine engine);
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DeinitializeEngine();
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DllCanUnloadNow();
      // variables privadas
      private FREngine.IEngine engine = null;
      // Handle de FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```

  ### C++ (COM)

  ```cpp theme={null}
  void UnloadFREngine()
  {
   if( libraryHandle == 0 ) {
    return;
   }
   // Liberar el objeto Engine
   Engine = 0;
   // Desinicializar FineReader Engine
   typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
   DeinitializeEngineFunc pDeinitializeEngine =
    ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
   if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
    throw L"Error al descargar ABBYY FineReader Engine";
   }
   // Ahora ya es seguro liberar la biblioteca FREngine.dll
   FreeLibrary( libraryHandle );
   libraryHandle = 0;
  }
  ```
</Accordion>

<div id="required-resources">
  ## Recursos necesarios
</div>

Puede utilizar el archivo [FREngineDistribution.csv](/es/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) para crear automáticamente una lista de los archivos necesarios para que su aplicación funcione. Para el procesamiento en este escenario, seleccione los siguientes valores en la columna 5 (RequiredByModule):

Core

Core.Resources

Opening

Opening, Processing

Processing

Processing.OCR

Processing.OCR, Processing.ICR

Processing.OCR.NaturalLanguages

Processing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguages

Si modifica el escenario estándar, cambie los módulos necesarios según corresponda. También debe especificar los idiomas de la interfaz, los idiomas de reconocimiento y cualquier función adicional que utilice su aplicación (como, por ejemplo, Opening.PDF si necesita abrir archivos PDF, o Processing.OCR.CJK si necesita reconocer texto en [idiomas CJK](/es/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk)). Consulte [Trabajar con el archivo FREngineDistribution.csv](/es/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) para obtener más información.

<div id="additional-optimization-for-specific-tasks">
  ## Optimización adicional para tareas específicas
</div>

* Escaneo: solo para Windows
  * [Escaneo](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/scanning)<br />Descripción del escenario de ABBYY FineReader Engine para el escaneo de documentos.

* Reconocimiento
  * [Ajuste de los parámetros de preprocesamiento, análisis, reconocimiento y síntesis](/es/fine-reader/engine/guided-tour/advanced-techniques/tuning-parameters-of-preprocessing-analysis-recognition-and-synthesis)<br />Personalización del procesamiento de documentos mediante objetos de parámetros de análisis, reconocimiento y síntesis.

* [Reconocer escritura a mano](/es/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts)<br />Los perfiles TextExtraction\_\*\*\* no incluyen el reconocimiento de texto manuscrito ni de texto en letras de imprenta. Si necesita reconocer escritura a mano, establezca la propiedad [DetectHandwritten](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams#detecthandwritten) del objeto [PageAnalysisParams](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams) en TRUE.

* [Objeto PageProcessingParams](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams)<br />Este objeto permite personalizar los parámetros de análisis y reconocimiento. Con este objeto, puede indicar qué características de la imagen y del texto deben detectarse (imagen invertida, orientación, códigos de barras, idioma de reconocimiento, margen de error de reconocimiento).

* [Objeto SynthesisParamsForPage](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsforpage)<br />Este objeto incluye parámetros responsables de restaurar el formato de una página durante la síntesis.

* [Objeto SynthesisParamsForDocument](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument)<br />Este objeto permite personalizar la síntesis del documento: restaurar su estructura y formato.

* [Objeto MultiProcessingParams](/es/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) - Solo para Linux y Windows<br />El procesamiento simultáneo puede resultar útil al procesar un gran número de imágenes. En este caso, la carga de procesamiento se distribuirá entre los núcleos del procesador durante la apertura y el preprocesamiento de imágenes, el análisis de diseño y el reconocimiento, lo que permite acelerar el procesamiento.<br />Los modos de procesamiento (simultáneo o consecutivo) se establecen mediante la propiedad MultiProcessingMode. La propiedad RecognitionProcessesCount controla el número de procesos que pueden iniciarse.

* Búsqueda de información importante
  * [Trabajar con Layout y Blocks](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-layout-and-blocks)<br />Información sobre el diseño de la página, los tipos de bloques y cómo trabajar con ellos.
  * [Objeto Layout](/es/fine-reader/engine/api-reference/layout-related-objects/layout)<br />Los parámetros de este objeto proporcionan acceso al diseño de la página y al texto reconocido tras el reconocimiento del documento.
  * [Trabajar con texto](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-text)<br />Trabajo con texto reconocido, párrafos, palabras y símbolos.

* Nueva lectura del documento con parámetros especiales para el tipo de datos especificado
  * [Reconocimiento a nivel de campo](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/field-level-recognition)<br />Descripción del escenario para reconocer segmentos cortos de texto.

* Guardado de datos
  * Para guardar los datos reconocidos, puede usar los métodos [Export](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) o [ExportPages](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/exportpages-method) del objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument) asignando la constante [FileExportFormatEnum](/es/fine-reader/engine/api-reference/enumerations/fileexportformatenum) como uno de los parámetros.
  * [Archivado de documentos](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving)<br />Descripción del escenario para guardar una copia electrónica del documento.

<div id="see-also">
  ## Consulte también
</div>

[Implementación de escenarios básicos de uso](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)