> ## 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.
# Archivado de documentos
> Archive documentos en papel con ABBYY FineReader Engine: preprocese escaneos, ejecute reconocimiento en paralelo y exporte a PDF con capacidad de búsqueda, PDF/A o PDF comprimido con MRC para almacenamiento a largo plazo.
Este escenario se utiliza para procesar documentos en papel y guardarlos en un archivo digital, especialmente al crear un archivo de contratos, documentación de proyectos, facturas, certificados, etc.
En este escenario de procesamiento, los documentos en papel se convierten en copias digitales no editables que contienen toda la información del documento en un formato con capacidad de búsqueda. Como resultado de este procesamiento, las copias digitales de los documentos pueden localizarse fácilmente en un archivo electrónico mediante búsquedas de texto completo, se pueden copiar fragmentos del texto del documento y los documentos pueden enviarse por correo electrónico o imprimirse.
Para crear una copia digital, el documento primero debe pasar por varias etapas de procesamiento, cada una de las cuales tiene sus propias particularidades:
1. Preprocesamiento de imágenes escaneadas
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 o una orientación o resolución incorrectas.
2. Reconocimiento simultáneo de un gran volumen de documentos
Para extraer datos de texto de un documento, primero debe reconocerse. Al procesar un gran volumen de documentos, el procesamiento simultáneo de documentos puede resultar útil. En este caso, la carga de trabajo del análisis y el reconocimiento puede distribuirse entre los núcleos del procesador, lo que permite acelerar el procesamiento.
3. Exportación a un formato de archivo
El documento reconocido se guarda en un formato de almacenamiento adecuado. Los formatos más convenientes para almacenar documentos son PDF, PDF/A, PDF y PDF/A con MRC. Al guardar en estos formatos, se puede usar un modo en el que el texto se coloca debajo de la imagen del documento; esto permite conservar íntegramente el formato del documento y habilita la búsqueda de texto completo. La configuración de MRC permite reducir significativamente el tamaño del archivo sin pérdida de calidad visual. Además, al guardar en formato PDF, se pueden personalizar los ajustes de seguridad del documento para protegerlo contra la visualización y la impresión no autorizadas.
## Implementación del escenario
Los ejemplos de código proporcionados en este tema son específicos de Windows.
A continuación se ofrece una descripción detallada del método recomendado para usar ABBYY FineReader Engine 12 para crear copias digitales de documentos con fines de archivo. El método propuesto utiliza la configuración de procesamiento más adecuada para este fin. En esta implementación se omite la fase de escaneo de documentos. Consulte [Optimización adicional para tareas específicas](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving#optimization) más abajo para obtener consejos sobre cómo implementar el escaneo.
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 su 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;
// 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}
// 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 usa 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";
}
}
```
ABBYY FineReader Engine permite cargar la configuración más adecuada para este escenario 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 [Trabajo con perfiles](/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:
Nombre del perfil
Descripción
DocumentArchiving\_Accuracy
La configuración se ha optimizado para ofrecer la máxima precisión:
Permite detectar la mayor cantidad posible de texto en una imagen, incluido el texto incrustado en ella.
No se realiza una reconstrucción completa de la estructura lógica de un documento.
El perfil no está pensado para convertir un documento a RTF, DOCX o PDF de solo texto. Utilice los perfiles de conversión de documentos para ese fin.
DocumentArchiving\_Speed
La configuración se ha optimizado para la velocidad de procesamiento:
Permite detectar la mayor cantidad posible de texto en una imagen, incluido el texto incrustado en ella.
No se corrige la inclinación.
No se realiza una reconstrucción completa de la estructura lógica de un documento.
Se aceleran los procesos de análisis y reconocimiento de documentos.
El perfil no está pensado para convertir un documento a RTF, DOCX o PDF de solo texto. Utilice los perfiles de conversión de documentos para ese fin.
### C\#
```csharp theme={null}
// Cargar un perfil predefinido
engine.LoadPredefinedProfile("DocumentArchiving_Accuracy");
```
### C++ (COM)
```cpp theme={null}
// Cargar un perfil predefinido
Engine->LoadPredefinedProfile( L"DocumentArchiving_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/document-archiving#optimization) para obtener más información.
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. El uso de este objeto le permite conservar la organización lógica del documento.
Para cargar imágenes de un único documento y preprocesarlas, debe crear el objeto FRDocument y agregarle imágenes. Puede realizar una de las siguientes acciones:
* 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 imágenes desde el archivo especificado.
* Crear el objeto FRDocument mediante el 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 (utilice 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}
// Crear el objeto FRDocument a partir de un archivo de imagen
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
```
Para reconocer un documento, se recomienda usar los métodos de análisis y reconocimiento del objeto FRDocument. Este objeto proporciona toda una serie de métodos para el análisis, el reconocimiento y la síntesis 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 capacidades de procesamiento simultáneo de los sistemas multiprocesador y multinúcleo. No obstante, también puede realizar secuencialmente 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}
// Analiza, reconoce y sintetiza el documento
// No se necesitan parámetros adicionales porque se configuran mediante el perfil de procesamiento
frDocument.Process( null );
```
### C++ (COM)
```cpp theme={null}
// Analiza, reconoce y sintetiza el documento
// No se necesitan parámetros adicionales porque se configuran mediante el perfil de procesamiento
frDocument->Process( 0 );
```
Para guardar un documento reconocido, 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 pasar la constante [FileExportFormatEnum](/es/fine-reader/engine/api-reference/enumerations/fileexportformatenum) como uno de los parámetros. En este caso, puede guardar el documento, por ejemplo, en formato PDF usando MRC en el modo de exportación PEM\_ImageOnText (propiedad TextExportMode del objeto [PDFExportParams](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams)). 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-archiving#optimization), más abajo, para obtener más información.
Después de terminar 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}
// Guarda un documento reconocido en un formato de archivo (por ejemplo, PDF)
// Crea un objeto PDFExportParams
FREngine.PDFExportParams exportParams = engine.CreatePDFExportParams();
// Establece los parámetros necesarios
exportParams.MRCMode = FREngine.PDFMRCModeEnum.MRC_Auto;
exportParams.TextExportMode = FREngine.PDFExportModeEnum.PEM_ImageOnText;
// Usa los parámetros durante la exportación
frDocument.Export( "C:\\MyText.pdf", FREngine.FileExportFormatEnum.FEF_PDF, exportParams );
// Libera el objeto FRDocument
frDocument.Close();
```
### C++ (COM)
```cpp theme={null}
// Guarda un documento reconocido en un formato de archivo (p. ej., PDF)
// Crea un objeto PDFExportParams
FREngine::IPDFExportParamsPtr params = Engine->CreatePDFExportParams();
// Establece los parámetros necesarios
params->MRCMode = FREngine::MRC_Auto;
params->TextExportMode = FREngine::PEM_ImageOnText;
// Usa los parámetros durante la exportación
frDocument->Export(L"C:\\MyText.pdf", FREngine::FEF_PDF, params);
// Libera el objeto FRDocument
frDocument->Close();
```
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, utilice 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 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;
}
```
## Recursos necesarios
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
Export.Pdf
Export.Pdf, Opening.Pdf
Si modifica el escenario estándar, cambie los módulos necesarios en consecuencia. También debe especificar los idiomas de la interfaz, los idiomas de reconocimiento y cualquier funcionalidad 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.
## Optimización adicional para tareas específicas
A continuación, se ofrece una descripción general de los temas de Ayuda que contienen información adicional sobre la personalización de la configuración en las distintas etapas del procesamiento de documentos:
* Escaneo - Solo para Windows
* [Escaneo](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/scanning) Descripción del escenario de ABBYY FineReader Engine para escanear 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) Personalización del procesamiento de documentos mediante objetos de parámetros para el análisis, el reconocimiento y la síntesis.
* [Reconocer escritura a mano](/es/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts) Los perfiles DocumentArchiving\_\*\*\* no incluyen el reconocimiento de texto manuscrito ni en letra 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) Este objeto permite configurar 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) Este objeto incluye los parámetros encargados 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) Este objeto permite personalizar la síntesis del documento, incluida la restauración de su estructura y formato.
* [Objeto MultiProcessingParams](/es/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) - Disponible para Linux y Windows El procesamiento simultáneo puede resultar útil cuando se procesa 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 del diseño, el reconocimiento y la exportación, lo que permite acelerar el procesamiento. Los modos de lectura (simultáneo o consecutivo) se establecen mediante la propiedad MultiProcessingMode, y la propiedad RecognitionProcessesCount controla el número de procesos que pueden iniciarse.
* Exportación
* [Ajuste de los parámetros de exportación](/es/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters) Personalización de la exportación de documentos mediante objetos de parámetros de exportación.
* [Objeto PDFExportParams](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams) Este objeto le permite ajustar la exportación a PDF (PDF/A) con solo unos pocos parámetros.
* Para personalizar el modo de exportación al formato PDF (PDF/A), use la propiedad [TextExportMode](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#textexportmode) del objeto PDFExportParams y, para personalizar la configuración de MRC, use la propiedad [MRCMode](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#mrcmode).
* Además, puede personalizar la configuración de exportación de imágenes para acelerar el procesamiento, reducir aún más el tamaño del archivo, etc. Por ejemplo, puede guardar una imagen en color como una imagen en escala de grises o en blanco y negro, si esto se ajusta a su caso de uso (use la propiedad [Colority](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#colority) del objeto PDFExportParams).
* Puede cambiar la resolución de la imagen de modo que la copia electrónica resultante pueda imprimirse posteriormente en una impresora o visualizarse en la pantalla de un ordenador, o bien puede seleccionar una resolución baja que solo permita leer el texto y ofrezca una calidad gráfica muy deficiente (use las propiedades [Resolution](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#resolution) y [ResolutionType](/es/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#resolutiontype) del objeto PDFExportParams).
* División en documentos
* En este escenario, puede que sea necesario separar el lote de imágenes en documentos. ABBYY FineReader Engine 12 no admite la separación automática de documentos. Sin embargo, puede usar ABBYY FlexiCapture Engine para implementar esta separación automática. Los documentos pueden separarse, por ejemplo, en función del número de páginas de cada documento o según si las páginas contienen códigos de barras separadores. Al implementar la separación por código de barras, puede usar el [escenario para extraer únicamente los valores de códigos de barras del documento](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition).
## Consulte también
[Implementación de escenarios básicos de uso](/es/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)