> ## 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.

# Reconocimiento de códigos de barras

> Use ABBYY FineReader Engine para leer códigos de barras para la separación, indexación y clasificación de documentos; ajuste la velocidad y la precisión con el perfil BarcodeRecognition.

En este escenario, ABBYY FineReader Engine se utiliza para leer códigos de barras. Puede ser necesario leer códigos de barras, por ejemplo, para separar documentos automáticamente, para procesar documentos mediante un sistema de gestión documental o para indexarlos y clasificarlos.

Este escenario puede utilizarse como parte de otros escenarios. Por ejemplo, los documentos escaneados con escáneres de producción de alta velocidad pueden separarse mediante códigos de barras, o los documentos preparados para su almacenamiento a largo plazo pueden incorporarse a sistemas de gestión documental de archivo en función de los valores de sus códigos de barras.

Al extraer códigos de barras de textos, el sistema puede detectar todos los códigos de barras o solo los de un tipo determinado con un valor determinado. El sistema puede obtener el valor de un código de barras y calcular su suma de comprobación. Para obtener los resultados más rápidos y de mayor calidad en el reconocimiento de códigos de barras:

1. Utilice imágenes en color con una resolución óptima de 300 dpi.

2. Ajuste la velocidad de reconocimiento mediante perfiles (consulte [Uso de perfiles](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles) para obtener más información).

Los valores reconocidos de los códigos de barras pueden guardarse en los formatos más adecuados para su posterior procesamiento, por ejemplo, en TXT.

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

<Note>
  Los ejemplos de código incluidos en este tema 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. Este método utiliza la configuración de procesamiento considerada más adecuada para este escenario.

<Accordion title="Paso 1. Carga de 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 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 encuentra la función InitializeEngine");
              }
              IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
              if (deinitializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("No se encuentra la función DeinitializeEngine");
              }
              IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
              if (dllCanUnloadNowPtr == IntPtr.Zero)
              {
                  throw new Exception("No se encuentra 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 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 puede seleccionarse 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 acepta como parámetro de entrada el nombre del perfil de configuración que se va a utilizar. Para obtener más información sobre los perfiles, consulte [Uso de perfiles](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles).

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

  | Nombre del perfil            | Descripción                                                                                                                                                                                                                                                                                                               |
  | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | BarcodeRecognition\_Accuracy | Extrae solo códigos de barras (no detecta texto, imágenes ni tablas). La configuración se ha optimizado para la precisión. <Warning> Este perfil requiere que el módulo [Barcode Autolocation](/es/fine-reader/engine/licensing/modules#barcode_autolocation) esté disponible en la licencia. </Warning>                  |
  | BarcodeRecognition\_Speed    | Extrae solo códigos de barras (no detecta texto, imágenes ni tablas). La configuración se ha optimizado para la velocidad de procesamiento. <Warning> Este perfil requiere que el módulo [Barcode Autolocation](/es/fine-reader/engine/licensing/modules#barcode_autolocation) esté disponible en la licencia. </Warning> |

  ### C\#

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

  ### C++ (COM)

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

  Si desea cambiar la configuración utilizada para el procesamiento, use los objetos Parameter correspondientes. Consulte la sección [Optimización adicional](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition#optimization) más abajo para obtener más información.
</Accordion>

<Accordion title="Paso 3. Carga y preprocesamiento de las imágenes">
  ABBYY FineReader Engine proporciona un objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument) para procesar documentos de varias páginas. Para cargar las imágenes de un documento y preprocesarlas, debe crear el objeto FRDocument y añadirle imágenes. Puede hacer una de las siguientes cosas:

  * Crear un 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 un objeto FRDocument y carga imágenes desde un archivo especificado.
  * Crear un objeto FRDocument con el método [CreateFRDocument](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) del objeto Engine y, después, agregar imágenes al objeto FRDocument creado desde un archivo (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. Extracción de códigos de barras">
  Si el perfil BarcodeRecognition está cargado, puede usar el método [Process](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method) del objeto FRDocument para extraer únicamente códigos de barras. En este caso, ABBYY FineReader Engine detecta solo bloques con códigos de barras. No detecta ningún otro bloque. Puede acceder a los bloques de códigos de barras reconocidos mediante el objeto [Layout](/es/fine-reader/engine/api-reference/layout-related-objects/layout), que es un subobjeto del objeto [FRPage](/es/fine-reader/engine/api-reference/document-related-objects/frpage) que representa una página del documento.

  Para leer códigos de barras de un tipo específico, especifique los parámetros correspondientes del objeto [BarcodeParams](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/barcodeparams) y pase el objeto BarcodeParams como parámetro a una de las funciones anteriores.

  ### C\#

  ```csharp theme={null}
  // Mientras el perfil BarcodeRecognition esté cargado,
  // no es necesario pasar parámetros adicionales al método de procesamiento
  // si los códigos de barras cumplen las especificaciones
  frDocument.Process( null );
  // Si necesita leer códigos de barras de un tipo específico
  // Cree un objeto DocumentProcessingParams
  FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
  // Especifique los parámetros necesarios
  dpp.PageProcessingParams.PageAnalysisParams.BarcodeParams.Type = ( int )FREngine.BarcodeTypeEnum.BT_Code39;
  // Ahora reconozca códigos de barras con estos parámetros
  frDocument.Process( dpp );
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Mientras el perfil BarcodeRecognition esté cargado,
  // no es necesario pasar parámetros adicionales al método de procesamiento
  // si los códigos de barras cumplen las especificaciones
  frDocument->Process( 0 );
  // Si necesita leer códigos de barras de un tipo específico
  // Cree un objeto DocumentProcessingParams
  FREngine::IDocumentProcessingParamsPtr params = Engine->CreateDocumentProcessingParams();
  // Especifique los parámetros necesarios
  params->PageProcessingParams->PageAnalysisParams->BarcodeParams->Type = FREngine::BT_Code39;
  // Ahora reconozca códigos de barras con estos parámetros
  frDocument->Process( params );
  ```
</Accordion>

<Accordion title="Paso 5. Exportación de los datos reconocidos">
  Para guardar en un archivo los valores de los códigos de barras reconocidos, puede usar 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) y asignar la constante [FileExportFormatEnum](/es/fine-reader/engine/api-reference/enumerations/fileexportformatenum) como uno de los parámetros. Por ejemplo, en este escenario se puede exportar a TXT. 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/barcode-recognition#optimization) más abajo para obtener más información.

  Cuando haya terminado 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}
  // Guarde los códigos de barras reconocidos en algún formato (por ejemplo, TXT)
  frDocument.Export( "C:\\barcodes.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
  // Libere el objeto FRDocument
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Guarde los códigos de barras reconocidos en algún formato (por ejemplo, TXT)
  frDocument->Export( L"C:\\barcodes.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
  // Libere el objeto FRDocument
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Paso 6. Descarga de ABBYY FineReader Engine">
  Después de terminar 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;
          // generar una 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;
      // 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}
  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 es seguro liberar la biblioteca FREngine.dll
   FreeLibrary( libraryHandle );
   libraryHandle = 0;
  }
  ```
</Accordion>

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

Puede usar 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 procesar con este escenario, seleccione en la columna 5 (RequiredByModule) los siguientes valores:

Core

Core.Resources

Opening

Opening, Processing

Processing

Processing.OCR

Processing.OCR, Processing.ICR

Processing.OCR.NaturalLanguages

Processing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguages

Export

Export, Processing

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 use 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 [Working with the FREngineDistribution.csv File](/es/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) para obtener más información.

<div id="additional-optimization">
  ## Optimización adicional
</div>

Estas son las secciones del archivo de ayuda donde puede encontrar información adicional sobre cómo configurar los parámetros para las distintas etapas de procesamiento:

* Extracción y lectura de códigos de barras
  * [BarcodeParams Object](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/barcodeparams)<br />Este objeto le permite configurar los parámetros de análisis y lectura de códigos de barras.
  * [Recognizing Barcodes](/es/fine-reader/engine/guided-tour/advanced-techniques/recognizing-barcodes)<br />Aborda casos especiales del reconocimiento de códigos de barras y ofrece sugerencias para trabajar con ellos.
  * [Barcode Types](/es/fine-reader/engine/specifications/barcode-types)<br />La lista de códigos de barras admitidos en ABBYY FineReader Engine 12 y una breve descripción de cada uno.
  * [FRDocument Object](/es/fine-reader/engine/api-reference/document-related-objects/frdocument)<br />Además de los valores de los códigos de barras, puede que necesite extraer otra información contenida en el documento. En ese caso, puede utilizar los métodos del objeto FRDocument.
  * [PageProcessingParams Object](/es/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams)<br />Este objeto le permite configurar los parámetros de análisis y reconocimiento para todo el documento. Con este objeto, puede especificar si deben reconocerse los valores de los códigos de barras. Se puede acceder a los parámetros de lectura de códigos de barras a través de las propiedades BarcodeParams y DetectBarcodes del subobjeto PageAnalysisParams.
  * [Working with Layout and Blocks](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-layout-and-blocks)<br />También puede marcar manualmente bloques de códigos de barras y especificar sus parámetros de análisis y lectura. En esta sección se proporciona información detallada sobre el trabajo con bloques.
* Trabajo con los valores reconocidos de los códigos de barras
  * [BarcodeBlock Object](/es/fine-reader/engine/api-reference/layout-related-objects/barcodeblock)<br />Las propiedades Text y BarcodeText de este objeto contienen el valor del código de barras obtenido mediante el reconocimiento. Las demás propiedades de este objeto pueden utilizarse para obtener el tipo de código de barras, su orientación y otros parámetros.
* Exportación
  * [Tuning Export Parameters](/es/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)<br />Configuración de la exportación mediante objetos de parámetros de exportación.
  * [TextExportParams Object](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/textexportparams)<br />Este objeto le permite configurar el guardado de los resultados del reconocimiento en archivos TXT.

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

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