Foxit Developer

Optimization ​

Optimization reduces PDF file size by compressing images, removing redundant data, and discarding unused user data, which saves disk space and makes PDFs easier to transfer and store. Starting in version 7.0, the optimization module can compress color, grayscale, and monochrome images in PDF files to further reduce file size.

Licensing

  • To use optimization, ensure your license includes the Optimization module.

Reduce PDF file size by compressing color, grayscale, and monochrome images ​

c++
#include "include/common/fs_common.h"
#include "include/pdf/fs_pdfdoc.h"
#include "include/pdf/fs_pdfpage.h"
#include "include/addon/optimization/fs_optimization.h"

using namespace std;
using namespace foxit;
using namespace foxit::common;
using namespace pdf;
using namespace foxit::addon;

PDFDoc doc("input_pdf_file");
ErrorCode error_code = doc.Load();
if (error_code != foxit::e_ErrSuccess) {
	printf("Error: %d\n", error_code);
	return 1;
}
Optimization_Pause pause(0,true);
addon::optimization::OptimizerSettings settings;
common::Progressive progressive =  addon::optimization::Optimizer::Optimize(doc,settings,&pause);
cout << "Optimized Start." << endl;
Progressive::State progress_state = Progressive::e_ToBeContinued;
while (Progressive::e_ToBeContinued == progress_state) {
	progress_state = progressive.Continue();
	int percent = progressive.GetRateOfProgress();
	String res_string;
	res_string.Format("Optimize progress percent: %d %",percent);
	std::cout<<res_string<<std::endl;
}
if(Progressive::e_Finished == progress_state)
{
	doc.SaveAs(L"ImageCompression_Optimized.pdf", foxit::pdf::PDFDoc::e_SaveFlagRemoveRedundantObjects);

}
cout << "Optimized Finish." << endl;
C
#include "include/fs_basictypes_c.h"
#include "include/fs_common_c.h"
#include "include/fs_pdfdoc_c.h"
#include "include/fs_pdfpage_c.h"
#include "include/fs_optimization_c.h"


FS_PDFDOC_HANDLE doc;
FSDK_PDFDoc_Create0(input_file, &doc);
FSErrorCode error_code = FSDK_PDFDoc_Load(doc, NULL);
if (error_code != e_FSErrSuccess) {
	FSDK_PDFDoc_Release(doc);
	printf("Error: %d\n", error_code);
	return 1;
}
Optimization_Pause pause(0,true);
FS_OPTIMIZERSETTINGS_HANDLE settings;
FSDK_OptimizerSettings_Create(&settings);
FS_PROGRESSIVE_HANDLE progressive = NULL;
FSDK_Optimizer_Optimize(doc, settings, &pause, &progressive);
printf("Optimized Start.\n");
FSState progress_state = e_FSToBeContinued;
int percent = 0;
while (e_FSToBeContinued == progress_state) {
	FSDK_Progressive_Continue(progressive, &progress_state);
	FSDK_Progressive_GetRateOfProgress(progressive, &percent);
	char res_string[60];
	sprintf_s(res_string, 60, "Optimize progress percent: %d %", percent);
	printf("%s\n", res_string);
}
if(e_FSFinished ==  progress_state)
{
               wchar_t output_directory_optimized[60];
	swprintf_s(output_directory_optimized, 60, L"%lsImageCompression_Optimized.pdf", output_directory);
	FS_BOOL return_result = false;
	FSDK_PDFDoc_SaveAs(doc, output_directory_optimized, e_FSSaveFlagRemoveRedundantObjects, &return_result);
}
printf("Optimized Finish.\n");
java
import com.foxit.sdk.common.Progressive;
import com.foxit.sdk.common.Constants;
import com.foxit.sdk.common.fxcrt.PauseCallback;
import com.foxit.sdk.pdf.PDFDoc;
import com.foxit.sdk.pdf.PDFPage;
import com.foxit.sdk.addon.*;
import com.foxit.sdk.addon.optimization.*;
import com.foxit.sdk.addon.optimization.Optimizer;

import java.io.File;
import static com.foxit.sdk.common.Constants.e_ErrSuccess;
import static com.foxit.sdk.pdf.PDFDoc.e_SaveFlagRemoveRedundantObjects;
PDFDoc doc = new PDFDoc("input_pdf_file");
error_code = doc.load(null);
if (error_code != e_ErrSuccess) {
    System.out.println(" Error: " + error_code);
    return;
}
PauseUtil pause = new PauseUtil();
OptimizerSettings settings = new OptimizerSettings();
System.out.println("Optimized Start.");
Progressive progressive = Optimizer.optimize(doc, settings, pause);
int state = Progressive.e_ToBeContinued;
while (state == Progressive.e_ToBeContinued) {
    state = progressive.resume();
    int rate = progressive.getRateOfProgress();
    System.out.println("Optimize progress percent: " +  rate + "%");
}
if(state == Progressive.e_Finished)
{
    doc.saveAs("ImageCompression_Optimized.pdf", e_SaveFlagRemoveRedundantObjects);
}
System.out.println("Optimized Finish.");
py
import sys
import site

if sys.version_info.major == 2:
    _PYTHON2_ = True
else:
    _PYTHON2_ = False

if _PYTHON2_:
    # replace with the python2 lib path
    site.addsitedir('../../../')
    from FoxitPDFSDKPython2 import *
else:
    from FoxitPDFSDKPython3 import *

...
doc = PDFDoc(input_file)
error_code = doc.Load("input_pdf_file")
if error_code != e_ErrSuccess:
    print("The Doc [{}] Error: {}\n".format(input_file, error_code))
    return 1

pause = Optimization_Pause(0, True)
settings = OptimizerSettings()
settings.SetOptimizerOptions(
    OptimizerSettings.e_OptimizerCompressImages)
progressive = Optimizer.Optimize(doc, settings, pause)
progress_state = Progressive.e_ToBeContinued
while Progressive.e_ToBeContinued == progress_state:
    progress_state = progressive.Continue()
    percent = progressive.GetRateOfProgress()
    print("Optimize progress percent: {} %".format(percent))
    if Progressive.e_Finished == progress_state:
        doc.SaveAs(output_directory + "ImageCompression_Optimized.pdf", PDFDoc.e_SaveFlagRemoveRedundantObjects)
print("Optimized Finish.")
objc
#include "FSPDFObjC.h"
...

NSString *input_file = [input_path stringByAppendingString:@"[Optimize]ImageCompression.pdf"];
FSPDFDoc *doc = [[FSPDFDoc alloc] initWithPath:input_file];
errorCode = [doc load:@""];
if (errorCode != FSErrSuccess) {
    NSLog(@"The Doc [%@] Error: %ld\n", input_file, errorCode);
    return -1;
}
PauseUtil* pause = [[PauseUtil alloc]initWithParam:30];
// Using default settings.
FSOptimizerSettings* settings = [[FSOptimizerSettings alloc]init];
NSLog(@"Optimized Start.");
FSProgressive *progressive = [FSOptimizer optimize:doc settings:settings pause:pause];
while ([progressive resume] == FSProgressiveToBeContinued) {
    int rate = [progressive getRateOfProgress];
    NSLog(@"Optimize progress percent: %d %%\n", rate);
}
NSString *output_file = [output_directory stringByAppendingPathComponent:@"ImageCompression_Optimized.pdf"];
[doc saveAs:output_file save_flags:FSPDFDocSaveFlagRemoveRedundantObjects];
NSLog(@"Optimized Finish.");
js
const FSDK = require("@fuxinsoft/foxit-pdf-sdk-node");

...
let doc = new FSDK.PDFDoc(input_file);
let error_code = doc.Load("");
if (error_code != FSDK.e_ErrSuccess) {
    console.log("The Doc [%s] Error: %d\n", input_path, error_code);
    return;
}
let pause = new Optimization_Pause(0, true);
let settings = new FSDK.OptimizerSettings();
let pause_callback = new FSDK.PauseCallback(pause);
settings.SetOptimizerOptions(FSDK.OptimizerSettings.e_OptimizerCompressImages);
let progressive = FSDK.Optimizer.Optimize(doc, settings, pause_callback);
let progress_state = FSDK.Progressive.e_ToBeContinued;
while (FSDK.Progressive.e_ToBeContinued == progress_state) {
    progress_state = progressive.Continue();
    let percent = progressive.GetRateOfProgress();
    let res_string = `Optimize progress percent:${percent} %`;        
}
if (FSDK.Progressive.e_Finished == progress_state) {
    doc.SaveAs(output_directory + "ImageCompression_Optimized.pdf", FSDK.PDFDoc.e_SaveFlagRemoveRedundantObjects);
}
csharp
using System;

using foxit;
using foxit.common;
using foxit.common.fxcrt;
using foxit.pdf;
using foxit.addon;
using foxit.addon.optimization;

using (PDFDoc doc = new PDFDoc("input_pdf_file"))
{ 
   error_code = doc.Load(null);
   if (error_code != ErrorCode.e_ErrSuccess)
   {
       Console.WriteLine("Document Load Error: {0}\n", error_code);
       return;
   }
   using (Optimization_Pause pause = new Optimization_Pause(0, true))
   using (OptimizerSettings settings = new OptimizerSettings())
   {
       Console.WriteLine("Optimized Start.\n");
       Progressive progressive = Optimizer.Optimize(doc, settings, pause);
       Progressive.State progress_state = Progressive.State.e_ToBeContinued;
       while (Progressive.State.e_ToBeContinued == progress_state)
       {
            progress_state = progressive.Continue();
            int percent = progressive.GetRateOfProgress();
            Console.WriteLine("Optimize progress percent: {0}%\n", percent);
       }
       if (Progressive.State.e_Finished == progress_state)
       {
            doc.SaveAs("ImageCompression_Optimized.pdf", (int)PDFDoc.SaveFlags.e_SaveFlagRemoveRedundantObjects);
       }
       Console.WriteLine("Optimized Finish.\n");
    }
}
go
import (
. "foxit.com/fsdk"
"fmt"
)

...
doc := NewPDFDoc(input_file)
error_code := doc.Load("input_pdf_file")
if error_code != E_ErrSuccess:
    fmt.Printf("The Doc [%s] Error: %d\n",input_file, error_code)
    return 1

pause := Optimization_Pause{0, true}
pause_ := NewDirectorPauseCallback(pause)
settings := NewOptimizerSettings()
settings.SetOptimizerOptions(OptimizerSettingsE_OptimizerCompressImages)
progressive := OptimizerOptimize(doc, settings, pause_)
progress_state := ProgressiveE_ToBeContinued
for ProgressiveE_ToBeContinued == progress_state {
    progress_state = progressive.Continue()
    percent := progressive.GetRateOfProgress()
    fmt.Printf("Optimize progress percent: %d %",percent)
    if ProgressiveE_Finished == progress_state{
        doc.SaveAs(output_directory + "ImageCompression_Optimized.pdf", PDFDocE_SaveFlagRemoveRedundantObjects)
}
}
fmt.Printf("Optimized Finish.")