DEV Community: E-iceblue Product Family

Save PDF as Image: A Complete Guide for Developers in Python

E-iceblue Product Family — Thu, 17 Sep 2026 03:14:28 +0000

PDF is one of the most widely used document formats for enterprise businesses, daily office work and internet services. However, the display and secondary editing of PDF files is limited on many platforms. Most front-end browsers, mobile devices and lightweight systems cannot render PDF content directly with high fidelity. It is also difficult to preview content, take screenshots, compare layouts and display PDF files in batches.

Converting PDF documents to images is the most efficient and universal solution to these problems. Python is a popular programming language with a wide range of tools and cross-platform capabilities, and can therefore perform stable, high-precision and automated batch PDF-to-image conversion. This is widely used in enterprise document management, system preview functions, bill identification, file archiving and other business scenarios.

Why Convert PDF to Images with Python?

In real-world development scenarios, using PDF files directly for business docking comes with many drawbacks. Unlike PDF files, image files are extremely compatible and can be previewed on almost all devices and systems without the need for professional PDF readers or plug-ins. Image files are also more convenient for secondary processing, such as picture compression, adding watermarks and identifying content, which greatly expands the scope for using document resources.

Python-based PDF-to-image conversion has unique advantages over traditional desktop conversion tools and online conversion platforms. Firstly, it supports local offline batch processing, completely avoiding the risk of enterprise document leakage caused by uploading files to third-party online servers. Secondly, the Python solution can be fully integrated with enterprise business systems to enable fully automated process integration without manual intervention. Additionally, it supports custom resolution, page range conversion, format specification, and other personalised configurations to meet the specific business needs of different industries.

Core Technical Principles of Python PDF to Image Conversion

With Spire.PDF for Python, the entire PDF-to-image conversion process retains the original layout of PDF documents, including text fonts, paragraph spacing, picture positions, table styles, colour matching and other details, ensuring zero distortion. At the same time, it provides perfect support for multi-page PDF files, enabling single-page and full-page batch conversion.

Simple PDF to PNG, JPG, and BMP Conversion

Spire.PDF offers the simple SaveAsImage method, enabling developers to export each page of a PDF document as their preferred image type. This built-in method handles page rendering internally, meaning that complex third-party dependencies are not required for PDF-to-image conversion.

from spire.pdf import *

# Load the PDF file
pdf = PdfDocument()
pdf.LoadFromFile("template.pdf")

# Loop through pages and save as images
for i in range(pdf.Pages.Count):
    # Convert each page to image
    with pdf.SaveAsImage(i) as image:

        # Save in different formats as needed
        image.Save(f"Output/ToImage_{i}.png")
        # image.Save(f"Output/ToImage_{i}.jpg")
        # image.Save(f"Output/ToImage_{i}.bmp")

# Close the PDF document
pdf.Close()

Crop Specific PDF Areas to Images: Crop PDF Sections with CropBox for Charts, Tables & Text Blocks

In many cases, you only need to export a specific part of a PDF page, such as a chart, table or block of text. You can achieve this by adjusting the page's CropBox property before rendering.
The CropBox property defines the area of the page that is visible for display and printing purposes. Assigning it a RectangleF(x, y, width, height) value allows you to isolate the target content and export only the selected section.

from spire.pdf import *

# Load the PDF document from file
pdf = PdfDocument()
pdf.LoadFromFile("Sample.pdf")

# Access the first page of the PDF
page = doc.Pages.get_Item(0)

# Define the crop area of the page using a rectangle (x, y, width, height)
page.CropBox = RectangleF(0.0, 300.0, 600.0, 260.0)

# Convert the cropped page to an image
with pdf.SaveAsImage(0) as image:
    # Save the image to a PNG file
    image.Save("Output/CropPDFSaveAsImage.png")

# Close the PDF document
pdf.Close()

Summary

PDF-to-image conversion is a key feature of enterprise-level intelligent document processing. Spire.PDF for Python allows developers to perform efficient, secure and highly accurate conversion of PDFs to images. It solves issues such as poor PDF compatibility and complex preview processing, meeting the varied requirements of business system development, document archiving and intelligent identification.

Converting Word Documents to PDF in Python: Complete Guide with Code Examples

E-iceblue Product Family — Thu, 10 Sep 2026 03:07:16 +0000

In today's digital workplace, document conversion is a routine yet essential task. Among all format conversions, transforming Microsoft Word documents (doc, .docx) into PDF files stands out as one of the most frequently requested operations. Whether you are generating reports, creating shareable archives, or producing print-ready documents, Python offers several powerful approaches to accomplish this task efficiently.

Why Convert Word to PDF?

PDF (Portable Document Format) preserves formatting across platforms and devices, making it the ideal choice for final document distribution. Unlike Word documents, which can render differently depending on the software version, fonts, or operating system, a PDF file looks identical everywhere. This consistency is crucial for legal documents, resumes, academic papers, and business reports.

This article will introduce a practical Python document processing library — Spire.Doc for Python. This library supports full-cycle Word document operations including document creation, reading, editing, comparison and format conversion, and delivers high-precision conversion effects with simple code logic. The following section provides detailed implementation methods for common Word-to-PDF conversion scenarios.

Convert Doc or Docx to PDF in Python
Convert Word to Secured PDF in Python
Convert Word to PDF with Fonts Embedded in Python

Convert Doc or Docx to Standard PDF in Python

This basic implementation enables the conversion of local Word documents (in both .doc and .docx formats) to standard PDF files with complete formatting retention.

from spire.doc import *
from spire.doc.common import *

# Create word document
document = Document()

# Load a doc or docx file
document.LoadFromFile("C:\\Users\\Administrator\\Desktop\\input.docx")

#Save the document to PDF
document.SaveToFile("output/ToPDF.pdf", FileFormat.PDF)
document.Close()

Convert Word to Password-Protected Secured PDF in Python

It is usually necessary to encrypt confidential business documents and private files before generating a PDF. The library supports the setting of passwords for opening documents and for granting permissions, as well as the configuration of encryption parameters, to protect file security.

from spire.doc import *
from spire.doc.common import *

# Create a Document object
document = Document()

# Load a Word file
document.LoadFromFile("C:\\Users\\Administrator\\Desktop\\input.docx")

# Create a ToPdfParameterList object
parameter = ToPdfParameterList()

# Specify open password and permission password
openPsd = "abc-123"
permissionPsd = "permission"

# Protect the PDF to be generated with open password and permission password
parameter.PdfSecurity.Encrypt(openPsd, permissionPsd, PdfPermissionsFlags.Default, PdfEncryptionKeySize.Key128Bit)

# Save the Word document to PDF
document.SaveToFile("output/ToPdfWithPassword.pdf", parameter)
document.Close()

Convert Word to PDF with Fonts Embedded in Python

Missing fonts are a common problem that can lead to distortion of the PDF format. Enabling font embedding during conversion packages all the fonts used in the original Word document into the PDF file, ensuring consistent display effects on any device without the need to install fonts.

from spire.doc import *
from spire.doc.common import *

# Create a Document object
document = Document()

# Load a Word file
document.LoadFromFile("C:\\Users\\Administrator\\Desktop\\input.docx")

# Create a ToPdfParameterList object
parameter = ToPdfParameterList()

# Embed fonts in PDF
parameter.IsEmbeddedAllFonts = True

# Save the Word document to PDF
document.SaveToFile("output/EmbedFonts.pdf", parameter)
document.Close()

Conclusion

Spire.Doc for Python allows developers to swiftly fulfill various Word-to-PDF conversion requirements, including standard, encrypted and font-embedded conversions. The solution features simple code, high conversion accuracy and reliable compatibility. It can be easily integrated into Python automation projects to help achieve efficient, standardized batch processing of office documents.

Python merge PDF files

E-iceblue Product Family — Wed, 09 Sep 2026 02:51:44 +0000

You've got three PDFs — a contract, an appendix, and a cover page — and you need them as a single file. You could fire up a GUI tool, drag-and-drop, wait for the spinner, and hope the page order didn't get scrambled. Or you could write a five-line Python script that does it reliably, every time, in a CI pipeline, a cron job, or a backend service.

Spire.PDF for Python lets you create, edit, and merge PDF documents entirely from Python code. No Java dependency, no COM automation, no Adobe Acrobat on the machine. Just pure Python with a full-featured PDF engine under the hood.

In this article, you will learn how to:

Install Spire.PDF for Python via pip
Merge two PDF files into one document
Combine an arbitrary number of PDFs from a folder
Insert pages from one PDF into the middle of another
Append content to an existing PDF without overwriting

Why merge PDFs in Python

Merging PDFs is one of those tasks that seems trivial until you need to do it at scale. A single pair of files? A desktop tool handles it. But what about:

Batch processing — hundreds of invoices that need to be combined by month
Automated reports — a cover page + generated charts + appendix, assembled on the fly
CI/CD pipelines — a build step that packages documentation artifacts
Serverless functions — a Lambda handler that merges uploaded chunks into a single deliverable

Python gives you the control and expressiveness to automate all of these without leaving the language.

Merge PDF files

The MergeFiles() method combines all PDFs in the list into a new PDF document object.

from spire.pdf.common import *
from spire.pdf import *

# Create a list of the PDF file paths
inputFile1 = "Sample1.pdf"
inputFile2 = "Sample2.pdf"
inputFile3 = "Sample3.pdf"
files = [inputFile1, inputFile2, inputFile3]

# Merge the PDF documents
pdf = PdfDocument.MergeFiles(files)

# Save the result document
pdf.Save("output/MergePDF.pdf", FileFormat.PDF)
pdf.Close()

Merge Selected Pages from PDFs in Python

In some cases, you may only want to merge specific pages of multiple PDFs. Spire.PDF for Python supports to select pages from different PDF documents and insert them into a new PDF file.

from spire.pdf import *
from spire.pdf.common import *

# Create a list of the PDF file paths
file1 = "Sample1.pdf"
file2 = "Sample2.pdf"
file3 = "Sample3.pdf"
files = [file1, file2, file3]

# Load each PDF file as an PdfDocument object and add them to a list
pdfs = []
for file in files:
    pdfs.append(PdfDocument(file))

# Create an object of PdfDocument class
newPdf = PdfDocument()

# Insert the selected pages from the loaded PDF documents into the new document
newPdf.InsertPage(pdfs[0], 0)
newPdf.InsertPage(pdfs[1], 1)
newPdf.InsertPageRange(pdfs[2], 0, 1)

# Save the new PDF document
newPdf.SaveToFile("output/SelectedPages.pdf")

Batch Processing: Merge Multiple PDF Files in a Folder

The Python script loops through each source PDF in a specified folder, then appends all pages from the source PDFs to a new PDF file.

import os 
from spire.pdf.common import *
from spire.pdf import *

# Specify the directory where the source PDFs are stored
folder = "pdf_folder/"  

# Create a new PDF to hold the combined content.
merged_pdf = PdfDocument()  

# Loop through each source PDF
for file in os.listdir(folder):  
    if file.endswith(".pdf"):  
        pdf = PdfDocument(os.path.join(folder, file))  
        # Appends all pages from each source PDF to the new PDF
        merged_pdf.AppendPage(pdf)  
        pdf.Close()  # Close source PDF

# Save the merged PDF after processing all files
merged_pdf.SaveToFile("BatchCombinePDFs.pdf")
merged_pdf.Close()  # Release resources

Merging PDF files in Python helps build server-side document pipelines, avoid manual PDF editors, and create reusable automation scripts for data and document workflows.

How to Add Images to a PDF in JavaScript (React) | Complete Guide

E-iceblue Product Family — Tue, 08 Sep 2026 03:48:29 +0000

When building PDFs dynamically within a React application — for use‑cases such as invoices requiring company logos, reports with embedded charts, or certificates with digital signatures — you often need to insert raster images onto PDF pages programmatically. Native JavaScript lacks built‑in support for modifying PDF internal structures, and spinning up a dedicated backend solely to overlay images is unnecessary overhead for tasks that can run client‑side.

Spire.PDF for JavaScript delivers a complete PDF engine compiled to WebAssembly, allowing your React application to create, modify, and export PDFs fully within the browser. All file operations take place inside the browser‑based Virtual File System (VFS), eliminating network round‑trips. Using the PdfImage class together with the page canvas DrawImage method, you gain precise control over image placement and dimensions inside your PDF files.

In this tutorial, you will learn how to:

Load an image into the VFS and convert it into a PdfImage object
Render images onto PDF pages with custom position and size settings
Insert images into newly‑created PDFs as well as pre‑existing PDF documents
Scale, center, and apply images across multiple PDF pages in batches
Trigger browser‑initiated downloads for your final generated PDF output

Why Generate and Modify PDFs in the Browser

Traditional workflows rely on server‑side PDF libraries including iText, PDFBox and similar tools: the browser uploads source files and image assets, processing happens server‑side, and the generated PDF is sent back to the client. While functional, this approach introduces notable pain points for PDF image‑insertion workflows:

Latency: Each PDF render depends on network round‑trips; performance degrades noticeably with large documents or poor network conditions.
Privacy: Original PDFs and image assets must leave the end‑user device, creating data‑exposure risks when handling confidential content.
Cost: PDF processing is CPU‑intensive, and scaling server‑based PDF operations incurs ongoing infrastructure expenses.

Spire.PDF for JavaScript shifts the entire workload to the browser via WebAssembly. Once the WASM module finishes loading, PDF processing runs locally with instant response times. Documents never leave the user’s device, and no server‑side compute resources are consumed.

Add an image to a new PDF

The simplest scenario: create a brand-new PDF document and draw an image onto its first page. The core steps are:

Load the image into the VFS using window.spire.FetchFileToVFS
Create a PdfDocument and add a blank page
Create a PdfImage from the loaded file with PdfImage.FromFile
Draw the image onto the page canvas with page.Canvas.DrawImage
Save and download the result

function App() {
  const addImageToPdf = async () => {
    // Get the Spire.PDF WASM module
    const pdfModule = window.wasmModule?.spirepdf;

    // Check if the WASM module is ready
    if (!pdfModule) {
      alert('Spire.PDF is not ready yet');
      return;
    }

    // Load the image into VFS
    const inputImageName = 'TreePic.png';
    await window.spire.FetchFileToVFS(inputImageName, "", `${process.env.PUBLIC_URL}/data/`);

    // Create a PdfDocument object
    let doc = new pdfModule.PdfDocument();

    // Add a page
    let page = doc.Pages.Add();

    // Load the image and scale its display size proportionally
    let image = pdfModule.PdfImage.FromFile(inputImageName);
    let width = image.Width * 0.6;
    let height = image.Height * 0.6;

    // Calculate the horizontal center position and set the vertical position
    let x = (page.Canvas.ClientSize.Width - width) / 2;
    let y = 60;

    // Draw the image at the specified position on the page
    page.Canvas.DrawImage({ image: image, x: x, y: y, width: width, height: height });

    // Define the output file name in PDF format
    const outputFileName = 'AddImage.pdf';

    // Save as PDF format
    doc.SaveToFile({ fileName: outputFileName });
    doc.Close();

    // Read the generated PDF file from VFS and trigger download
    const fileArray = window.dotnetRuntime.Module.FS.readFile(outputFileName);
    const blob = new Blob([fileArray], { type: 'application/pdf' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = outputFileName;
    a.click();
    URL.revokeObjectURL(url);
  };

  return (
    <div style={{ textAlign: 'center', height: '300px' }}>
      <h1>Add Image To PDF</h1>
      <button onClick={addImageToPdf}>
        Generate
      </button>
    </div>
  );
}

export default App;

What the code does:

PdfImage.FromFile(inputImageName) reads the image from the VFS and creates a PdfImage object. The original pixel dimensions are available via image.Width and image.Height.
page.Canvas.DrawImage(...) renders the image onto the page. The x and y parameters set the top-left corner position, and width and height control the display size.
The image is scaled to 60% of its original size (* 0.6) and horizontally centered using (page.Canvas.ClientSize.Width - width) / 2.

Add an image to an existing PDF

Adding an image to an existing document follows the same pattern — the only difference is that instead of creating a new PdfDocument, you load one from the VFS and select the target page.

const addImageToExistingPdf = async () => {
  const pdfModule = window.wasmModule?.spirepdf;
  if (!pdfModule) return;

  // Load both the PDF and the image into VFS
  await window.spire.FetchFileToVFS('Report.pdf', "", `${process.env.PUBLIC_URL}/data/`);
  await window.spire.FetchFileToVFS('Logo.png', "", `${process.env.PUBLIC_URL}/data/`);

  // Load the existing PDF
  let doc = new pdfModule.PdfDocument();
  doc.LoadFromFile('Report.pdf');

  // Get the first page (or any page you want)
  let page = doc.Pages.get_Item(0);

  // Load the image and draw it at the top-right corner
  let image = pdfModule.PdfImage.FromFile('Logo.png');
  let imgWidth = 80;
  let imgHeight = 40;
  let x = page.Canvas.ClientSize.Width - imgWidth - 30; // 30pt margin from right edge
  let y = 30; // 30pt from top

  page.Canvas.DrawImage({ image: image, x: x, y: y, width: imgWidth, height: imgHeight });

  // Save and download
  const outputFileName = 'ReportWithLogo.pdf';
  doc.SaveToFile({ fileName: outputFileName });
  doc.Close();

  const fileArray = window.dotnetRuntime.Module.FS.readFile(outputFileName);
  const blob = new Blob([fileArray], { type: 'application/pdf' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = outputFileName;
  a.click();
  URL.revokeObjectURL(url);
};

Key difference from the new-document example: doc.LoadFromFile('Report.pdf') loads an existing PDF instead of starting from scratch, and doc.Pages.get_Item(0) retrieves a page from the loaded document. The rest of the drawing logic is identical.

Scaling and positioning

The DrawImage method gives you full control over where and how large the image appears. Here are the most common patterns:

Proportional scaling — multiply both dimensions by the same factor to preserve the aspect ratio:

let scale = 0.5; // 50% of original size
let width = image.Width * scale;
let height = image.Height * scale;

Fixed width, auto height — set the width and calculate height to preserve the aspect ratio:

let targetWidth = 200;
let width = targetWidth;
let height = image.Height * (targetWidth / image.Width);

Horizontal centering — place the image equidistant from the left and right page margins:

let x = (page.Canvas.ClientSize.Width - width) / 2;

Vertical centering — place the image equidistant from the top and bottom of the page:

let y = (page.Canvas.ClientSize.Height - height) / 2;

Custom position — use absolute coordinates (origin is top-left, units are points; 1 point = 1/72 inch):

let x = 72;  // 1 inch from left
let y = 144; // 2 inches from top

Add images to multiple pages

To add the same image (e.g., a logo or watermark) to every page in a document, loop through the Pages collection:

const addImageToAllPages = async () => {
  const pdfModule = window.wasmModule?.spirepdf;
  if (!pdfModule) return;

  await window.spire.FetchFileToVFS('Business_Data_Overview.pdf', "", `${process.env.PUBLIC_URL}/data/`);
  await window.spire.FetchFileToVFS('Logo.png', "", `${process.env.PUBLIC_URL}/data/`);

  let doc = new pdfModule.PdfDocument();
  doc.LoadFromFile('Business_Data_Overview.pdf');

  let image = pdfModule.PdfImage.FromFile('Logo.png');
  let imgWidth = 60;
  let imgHeight = 30;

  // Loop through all pages and draw the logo in the top-right corner
  for (let i = 0; i < doc.Pages.Count; i++) {
    let page = doc.Pages.get_Item(i);
    let x = page.Canvas.ClientSize.Width - imgWidth - 20;
    let y = 20;
    page.Canvas.DrawImage({ image: image, x: x, y: y, width: imgWidth, height: imgHeight });
  }

  const outputFileName = 'AllPagesWithLogo.pdf';
  doc.SaveToFile({ fileName: outputFileName });
  doc.Close();

  const fileArray = window.dotnetRuntime.Module.FS.readFile(outputFileName);
  const blob = new Blob([fileArray], { type: 'application/pdf' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = outputFileName;
  a.click();
  URL.revokeObjectURL(url);
};

This pattern is useful for adding watermarks, company logos, or page stamps uniformly across a multi-page document.

Download the result

After saving the PDF to the VFS with doc.SaveToFile(), you need to read it back and trigger a browser download. This two-step pattern — save to VFS, then read from VFS — is used in every Spire.PDF for JavaScript example:

// 1. Save the PDF to the VFS
doc.SaveToFile({ fileName: 'Output.pdf' });
doc.Close();

// 2. Read the file from VFS as a byte array
const fileArray = window.dotnetRuntime.Module.FS.readFile('Output.pdf');

// 3. Create a Blob and trigger download
const blob = new Blob([fileArray], { type: 'application/pdf' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'Output.pdf';
a.click();
URL.revokeObjectURL(url);

With Spire.PDF for JavaScript, all PDF image editing and generation tasks run locally in the browser via WebAssembly. After initializing the WASM module, all rendering operations execute instantly on the client side. No files are uploaded externally, no server resources are required, and the entire PDF image embedding process is faster, safer, and cost-free.

From Static Documents to Dynamic Web Pages: PDF-to-HTML Conversion in Python

E-iceblue Product Family — Fri, 04 Sep 2026 06:21:44 +0000

In today's increasingly digitized information landscape, the PDF format has long reigned supreme for document exchange. It faithfully preserves layout, fonts and images, ensuring cross-platform 'what you see is what you get' consistency. However, it is precisely this closed, static nature that makes PDF the biggest obstacle to circulation and reuse in the modern web ecosystem.

The format barrier becomes glaringly obvious when we need to extract, display, interact with or integrate information from PDFs into web systems. Python, with its rich ecosystem and powerful text processing capabilities, offers a highly efficient and controllable engineering-grade solution for this conversion process. Rather than delving into specific algorithm implementations, this article focuses on why to do it, what problems it solves, and how to integrate your existing conversion code into an automated workflow.

PDF to HTML: More Than a Format Change

Converting from PDF to HTML is, at its core, transforming a static visual presentation into a dynamic, structured document. This necessity manifests across several key business scenarios:

Web Content Publishing and Integration Enterprise knowledge bases, product manuals, legal documents, and more are largely stored as PDFs. Converting them directly to HTML allows seamless embedding into CMS platforms, corporate portals, or internal management dashboards, enabling online browsing and searching without requiring users to download files.
Responsive and Accessible Viewing PDFs often deliver a poor reading experience on mobile devices and are difficult to adapt to screen readers and other assistive tools. HTML natively supports fluid layouts and WAI-ARIA accessibility standards, meeting the needs of multi-device and diverse user audiences.
Data Extraction and Reuse Tables, charts, and paragraph text locked inside a PDF's fixed layout become accessible once converted to HTML. Content can then be parsed via DOM, styled with CSS, and enhanced with JavaScript interactivity — opening the door to downstream data mining, information retrieval, and automated processing.
Full-Text Search and SEO Search engines crawl and index HTML content far more effectively than PDFs. Converting public-facing documents to HTML pages significantly improves online visibility and search efficiency.

Tackling the pain points: Four Real-World Challenges

In practical engineering deployments, PDF-to-HTML is never as simple as calling a single function. A truly valuable conversion solution must confront the following common pain points:

Pain Point 1: "Out-of-Order" Text and Content Loss

A PDF's internal structure is a collection of page description objects, not a flowing text stream. Multi-column layouts, mixed text and images, headers, footers, and footnotes are all prone to scrambled reading order, missing images, or overlapping content during conversion. Quality solutions rely on deep parsing engines combined with layout analysis logic — not simple text extraction.

Pain Point 2: Font and Style Incompatibility

Commercial fonts, special symbols, or custom encodings used in PDFs may not be rendered in the Web environment. Conversion results often show garbled text, placeholder characters, or collapsed styling. This demands font mapping, fallback font declarations, and CSS style cleaning during conversion to ensure visual fidelity of the output.

Pain Point 3: Batch Processing and Performance Bottlenecks

When facing hundreds of pages or thousands of PDF files, single-threaded processing speed and memory management become critical challenges. An engineering-grade solution must support asynchronous task queues, resumable transfers, and failure retry mechanisms — so that one problematic document doesn't bring down the entire pipeline.

Implementable Solutions

Spire.PDF for python supports to convert PDF to HTML in Python. It covers everything from basic conversions and advanced customization to stream-based output—each section includes practical, easy-to-follow code snippets to help you get started quickly.

Basic PDF-to-HTML Conversion Example

Spire.PDF makes it easy to export an entire PDF document to HTML using the SaveToFile() method.

from spire.pdf.common import *
from spire.pdf import *

# Initialize a PdfDocument object
doc = PdfDocument()

# Load your PDF file
doc.LoadFromFile("Sample.pdf")

# Convert and save it as HTML
doc.SaveToFile("PdfToHtml.html", FileFormat.HTML)

# Close the document
doc.Close()

Custom PDF-to-HTML Output Effects

We can use SetPdfToHtmlOptions() method to customize various aspects of the conversion—such as image embedding, page splitting, and SVG quality to set the HTML output.

from spire.pdf.common import *
from spire.pdf import *

# Initialize a PdfDocument object
doc = PdfDocument()
# Load your PDF file
doc.LoadFromFile("Sample.pdf")

# Access conversion settings
options = doc.ConvertOptions

# Customize conversion: use image embedding, one page per file
options.SetPdfToHtmlOptions(False, True, 1, False)

# Save the PDF to HTML with the custom options
doc.SaveToFile("PdfToHtmlWithOptions.html", FileFormat.HTML)
# Close the document
doc.Close()

Saving PDF as an HTML Stream

In web or cloud-based applications, you might prefer to write the HTML output to a stream instead of saving directly to the file system via SaveToStream() method.

from spire.pdf.common import *
from spire.pdf import *

# Initialize a PdfDocument object
doc = PdfDocument()
# Load your PDF file
doc.LoadFromFile("Sample.pdf")

# Create a stream to save the HTML output
fileStream = Stream("PdfToHtmlStream.html")

# Save the PDF to HTML stream
doc.SaveToStream(fileStream, FileFormat.HTML)

# Close the stream and the document
fileStream.Close()
doc.Close()

Conclusion: The Value Lies in "Releasing," Not "Replacing"

Converting PDF to HTML using Python is an effective way to make your documents web-compatible and more interactive. PDF-to-HTML conversion is not meant to negate the archival value of PDFs. Rather, it is about releasing the information vitality trapped within fixed layouts. Under the support of Python's ecosystem, automated batch PDF-to-HTML conversion significantly improves document processing efficiency and deepens content reuse.

Java Convert PDF to Excel and Excel to PDF

E-iceblue Product Family — Fri, 14 Jan 2022 09:42:10 +0000

In our daily lives, we use PDFs and Excels in a variety of ways. We know the data in PDFs can't be edited easily, whereas the data in an Excel spreadsheet can be freely edited. Occasionally, we don't want others to change the data; at other times, we need to edit the data in the files. In this article, I am going to show you how to convert PDF document to Excel and Excel to PDF by using Spire.Office for Java from the following four parts.

Convert each PDF page to a single Excel worksheet
Convert a Multi-Page PDF to One Excel Worksheet
Convert a Whole Excel File to PDF
Convert a Specific Worksheet to PDF

Install Spire.Office.jar

Spire.Office for Java supports to operate Word, Excel, PowerPoint and PDF files from Java. If you’re creating a Maven project, you can easily add the jar in your application using the following configurations. For non-Maven projects, download the jar file from this link and add it as a dependency in your application.

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.office</artifactId>
        <version>4.12.2</version>
    </dependency>
</dependencies>

Convert each PDF page to a single Excel worksheet

The details steps to convert each PDF page to a single Excel worksheet.

Create a PdfDocument object.
Load a sample PDF file using PdfDocument.loadFromFile() method.
Save the PDF file to Excel using PdfDocument.saveToFile() method.

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;

public class PdftoExcel {
    public static void main(String[] args) throws Exception {

        //create a PdfDocument instance
        PdfDocument pdf = new PdfDocument();

        //Load a sample PDF file
        pdf.loadFromFile("Sample.pdf");

        //Save to Excel
        pdf.saveToFile("out/ToExcel.xlsx", FileFormat.XLSX);

        }
    }

Convert a Multi-Page PDF to One Excel Worksheet

The details steps to convert a PDF file containing 2 pages to one Excel worksheet.

Create a PdfDocument object.
Load a sample PDF file using PdfDocument.loadFromFile() method.
Set the PDF to XLSX conversion options to render multiple PDF pages on a single worksheet using PdfDocument.getConvertOptions().setPdfToXlsxOptions() method.
Save the PDF file to Excel using PdfDocument.saveToFile() method.

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.conversion.XlsxLineLayoutOptions;


public class PdftoExcel {
    public static void main(String[] args) throws Exception {

        //create a PdfDocument instance
        PdfDocument pdf = new PdfDocument();
        //Load a sample PDF file
        pdf.loadFromFile("Sample.pdf");

        //Set the PDF to XLSX conversion options: rendering multiple pages on a single worksheet
        pdf.getConvertOptions().setPdfToXlsxOptions(new XlsxLineLayoutOptions(false,true,true));

        //Save to Excel
        pdf.saveToFile("out/ToOneSheet.xlsx", FileFormat.XLSX);

        }
    }

Convert a Whole Excel File to PDF

The details steps to convert an Excel Workbook with two worksheets to a PDF.

Create a Workbook object.
Load a sample Excel document using Workbook.loadFromFile() method.
Set the Excel to PDF conversion options through the methods under the ConverterSetting object, which is returned by Workbook.getConverterSetting() method.
Convert the whole Excel document to PDF using Workbook.saveToFile() method.

import com.spire.xls.FileFormat;
import com.spire.xls.Workbook;

public class ExceltoPDF {
    public static void main(String[] args) throws Exception {

        //Create a Workbook instance and load an Excel file
        Workbook workbook = new Workbook();
        workbook.loadFromFile("Sample.xlsx");

        //Set worksheets to fit to page when converting
        workbook.getConverterSetting().setSheetFitToPage(true);

        //Save the resulting document to a specified path
        workbook.saveToFile("out/ExcelToPdf.pdf", FileFormat.PDF);
        }
    }

Convert a Specific Worksheet to PDF

The details steps to convert a specific Excel worksheet to a PDF.

Create a Workbook object and load a sample Excel document using Workbook.loadFromFile() method.
Set the Excel to PDF conversion options through the methods under the ConverterSetting object, which is returned by Workbook.getConverterSetting() method.
Get a specific worksheet using Workbook.getWorksheets().get() method.
Convert the worksheet to PDF using Worksheet.saveToPdf() method.

import com.spire.xls.FileFormat;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;

public class ExceltoPDF {
    public static void main(String[] args) throws Exception {

        //Create a Workbook instance and load an Excel file
        Workbook workbook = new Workbook();
        workbook.loadFromFile("Sample.xlsx");

        //Set worksheets to fit to page when converting
        workbook.getConverterSetting().setSheetFitToPage(true);

        //Get the first worksheet
        Worksheet worksheet = workbook.getWorksheets().get(0);

        //Save the resulting document to a specified path
        worksheet.saveToPdf("out/WorksheetToPdf.pdf");

        }
    }

Convert Excel to CSV and Vice Versa in Java

E-iceblue Product Family — Tue, 11 Jan 2022 04:02:27 +0000

CSV files are delimited text files in which values are separated by commas. They can be used with most spreadsheet programs, such as Microsoft Excel and Google Spreadsheets. Sometimes, you might need to do conversions between Excel and CSV. In this article, I will demonstrate how to convert Excel to CSV and CSV to Excel in Java using Spire.XLS for Java library.

Add Dependencies

To begin with, you need to add needed dependencies for including Spire.XLS for Java library into your Java project.
You can either download the library’s jar from the official website or install it from Maven by adding the following code to your maven-based project’s pom.xml file.

<repositories>    
    <repository>    
        <id>com.e-iceblue</id>    
        <name>e-iceblue</name>    
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>    
    </repository>    
</repositories>    
<dependencies>    
    <dependency>    
        <groupId>e-iceblue</groupId>    
        <artifactId>spire.xls</artifactId>    
        <version>4.12.2</version>    
    </dependency>    
</dependencies>

Convert Excel to CSV using Java

You can convert an Excel worksheet to CSV or convert multiple worksheets to separate CSV files as per your requirement.

The following are the steps to convert an Excel worksheet to CSV:

Create an instance of Workbook class.
Load an Excel file using Workbook.loadFromFile() method.
Get the desired worksheet by its index using Workbook.getWorksheets().get(index) method.
Save the worksheet as CSV using XlsWorksheet.saveToFile(String fileName, String separator, Charset encoding) method. You may also choose one of the other two overloaded methods below:

a. saveToFile(String fileName, String separator)

b. saveToFile(String fileName, String separator, boolean retainHiddenData)

import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;

import java.nio.charset.Charset;

public class ConvertAWorksheetToCsv {
    public static void main(String []args){
        //Create an instance of Workbook class
        Workbook workbook = new Workbook();
        //Load an Excel file
        workbook.loadFromFile("Sample.xlsx");

        //Get the first worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        //Save the worksheet as CSV
        sheet.saveToFile("ExcelToCSV.csv", ",", Charset.forName("UTF-8"));
    }
}

The above code saves only the first worksheet in the Excel file as CSV. If you want to save multiple worksheets in the Excel file as separate CSV files, use the following code.

import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;

import java.nio.charset.Charset;

public class ConvertMultipleWorksheetsToCsv {
    public static void main(String []args) {
        //Create an instance of Workbook class
        Workbook workbook = new Workbook();
        //Load an Excel file
        workbook.loadFromFile("Sample.xlsx");

        //Loop through the worksheets in the Excel file
        for (int i = 0; i < workbook.getWorksheets().getCount(); i++) {
            Worksheet sheet = workbook.getWorksheets().get(i);
            //Save each worksheet as a separate CSV
            sheet.saveToFile("Output/ExcelToCSV_" + i + ".csv", ",", Charset.forName("UTF-8"));
        }
    }
}

Convert CSV to Excel using Java

The following are the steps to convert a CSV to Excel:

Create an instance of Workbook class.
Load a CSV file using Workbook.loadFromFile(String fileName, String separator, int row, int column) method.
Loop through the worksheets in the CSV file.
Within the loop, access the used range of the current worksheet using Worksheet.getAllocatedRange() method. Then set ignore error option using XlsRange.setIgnoreErrorOptions() method. After that, autofit columns and rows using XlsRange.autoFitColumns() and XlsRange.autoFitRows() method.
Save the CSV to Excel using Workbook.saveToFile(string fileName, ExcelVersion version) method.

import com.spire.xls.*;

import java.util.EnumSet;

public class ConvertCsvToExcel {
    public static void main(String []args) {
        //Create an instance of Workbook class
        Workbook workbook = new Workbook();

        //Load a CSV file
        workbook.loadFromFile("ExcelToCSV.csv", ",", 1, 1);

        //Loop through the worksheets in the CSV file
        for (int i = 0; i < workbook.getWorksheets().getCount(); i++)
        {
            Worksheet sheet = workbook.getWorksheets().get(i);
            //Access the used range in each worksheet
            CellRange usedRange = sheet.getAllocatedRange();
            //Ignore errors when saving numbers in the used range with text
            usedRange.setIgnoreErrorOptions(EnumSet.of(IgnoreErrorType.NumberAsText));
            //Autofit columns and rows
            usedRange.autoFitColumns();
            usedRange.autoFitRows();
        }

        //Save the result file
        workbook.saveToFile("CSVToExcel.xlsx", ExcelVersion.Version2013);
    }
}

See More

Product Page | Documentation | Forum |

How to Increase or Decrease Margins of an Existing PDF in Java

E-iceblue Product Family — Thu, 06 Jan 2022 12:14:19 +0000

Margins refer to the blank area around a PDF page. In certain cases, you may need to adjust the margins of your PDF documents. For example, before merging multiple PDF documents into a single PDF, you may want to change the margins so that all documents have the same page size. This article will show you how to increase or decrease margins of an existing PDF document using Spire.PDF for Java.

Installing Spire.Pdf.jar

If you use Maven, you can easily import the Spire.Pdf.jar in your application by adding the following code to your project’s pom.xml file. For non-Maven projects, download the jar file from this link and manually add it as a dependency in your application.

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId> e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <verson>4.11.2</version>
    </dependency>
</dependencies>

Example 1. Increase Margins of an Existing PDF

To enlarge the margin of a PDF document, the basic thought is to create a new PDF that has bigger page size and then draw the original page on the big page at a proper position. The following code snippet will show you how to turn ideas into reality step by step.

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.graphics.PdfMargins;
import com.spire.pdf.graphics.PdfTemplate;

import java.awt.*;
import java.awt.geom.Dimension2D;
import java.awt.geom.Point2D;

public class IncreaseMargins {

    public static void main(String[] args) {

        //Load the original PDF document
        PdfDocument originalPdf = new PdfDocument("C:\\Users\\Administrator\\Desktop\\Table.pdf");

        //Get first page
        PdfPageBase firstPage = originalPdf.getPages().get(0);

        //Create a new PdfDocument object
        PdfDocument newPdf = new PdfDocument();

        //Set increasing value of the page margin
        PdfMargins margins = newPdf.getPageSettings().getMargins();
        margins.setTop(40);
        margins.setBottom(40);
        margins.setLeft(40);
        margins.setRight(40);

        //Set the page size of the new PDF document
        Dimension2D dimension2D = new Dimension();
        dimension2D.setSize(firstPage.getSize().getWidth() + margins.getLeft()+margins.getRight(), firstPage.getSize().getHeight() + margins.getTop()+margins.getBottom());
        newPdf.getPageSettings().setSize(dimension2D);

        //Loop through the pages in the original document
        for (int i = 0; i < originalPdf.getPages().getCount(); i++) {

            //Create template based on the source page
            PdfTemplate template = originalPdf.getPages().get(i).createTemplate();

            //Add a page to the new PDF
            PdfPageBase page = newPdf.getPages().add(dimension2D);

            //Draw template on the page
            template.draw(page.getCanvas(), new Point2D.Float(0, 0));
        }

        //Save the new document to file
        newPdf.saveToFile("output/IncreaseMargins.pdf", FileFormat.PDF);
    }
}

Example 2. Decrease Margins of an Existing PDF

Likewise, the way to decrease the margins of a PDF is to create a new PDF that has smaller page size and then draw the source page on the small page at a specified coordinate. It’s worth mentioning that the decreasing value on the left, right, top or bottom direction should be less than the existing margins. Otherwise, the content area might be cut off while decreasing the margins.

import com.spire.pdf.FileFormat;
import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.graphics.PdfMargins;
import com.spire.pdf.graphics.PdfTemplate;

import java.awt.*;
import java.awt.geom.Dimension2D;
import java.awt.geom.Point2D;

public class DecreaseMargins {
    public static void main(String[] args) {

        //Load the original PDF document
        PdfDocument originalPdf = new PdfDocument("C:\\Users\\Administrator\\Desktop\\Table.pdf");

        //Get the first page
        PdfPageBase firstPage = originalPdf.getPages().get(0);

        //Create a new PdfDocument object
        PdfDocument newPdf = new PdfDocument();

        //Set decreasing value
        double left = 20;
        double right = 20;
        double top = 20;
        double bottom = 20;

        //Set the page size of the new PDF document
        Dimension2D dimension2D = new Dimension();
        dimension2D.setSize(originalPdf.getPages().get(0).getSize().getWidth() - left - right , originalPdf.getPages().get(0).getSize().getHeight() - top -bottom);

        //Loop through the pages in the original document
        for (int i = 0; i < originalPdf.getPages().getCount(); i++) {

            //Create template based on the source page
            PdfTemplate template = originalPdf.getPages().get(i).createTemplate();

            //Add a page to the new PDF
            PdfPageBase page = newPdf.getPages().add(dimension2D, new PdfMargins(0));

            //Draw template on the page
            template.draw(page.getCanvas(), new Point2D.Float(-20, -20));
        }

        //Save the new document to file
        newPdf.saveToFile("output/DecreaseMargins.pdf", FileFormat.PDF);
    }
}

Java Hide and Show Rows or Columns in Excel

E-iceblue Product Family — Fri, 31 Dec 2021 02:22:58 +0000

With the help of Spire.XLS for Java, we can easily hide and show the rows or columns in the Excel worksheets programmatically. In this article, we will demonstrate how to hide and show rows or columns in Excel in Java applications from the following four parts.

Hide Excel Rows and Columns
Show Hidden Rows and Columns in Excel
Hide Multiple Rows and Columns
Show All Hidden Rows and Columns

Install Spire.XLS for Java

First of all, you're required to add the Spire.Xls.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's pom.xml file.

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.xls</artifactId>
        <version>4.12.2</version>
    </dependency>
</dependencies>

Hide Rows and Columns

Create a Workbook instance and load a sample Excel document using Workbook.loadFromFile() method.
Get a specified worksheet using Workbook.getWorksheets().get() method.
Hide the column using Worksheet.hideColumn(int columnIndex)method.
Hide the row using worksheet.hideRow(int rowIndex) method. Save the document to file using Workbook.saveToFile() method.

import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;


public class HideRowsColumns {
    public static void main(String[] args) throws Exception {

        //Load the sample document
        Workbook wb = new Workbook();
        wb.loadFromFile("Sample.xlsx ");

        //Get the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Hide the third column
        sheet.hideColumn(3);

        //Hide the third row
        sheet.hideRow(3);

        //Save the document
        wb.saveToFile("HideRowsColumns.xlsx", ExcelVersion.Version2016);
    }
}

Show Hidden Rows and Columns

Create a Workbook instance and load a sample Excel document using Workbook.loadFromFile() method.
Get a specified worksheet using Workbook.getWorksheets().get() method.
Show the column using Worksheet.showColumn(int columnIndex)method.
Show the row using worksheet.showRow(int rowIndex) method.
Save the document to file using Workbook.saveToFile() method.

import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;


public class ShowRowsColumns {
    public static void main(String[] args) throws Exception {

        //Load the sample document
        Workbook wb = new Workbook();
        wb.loadFromFile("HideRowsColumns.xlsx ");

        //Get the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Unhide the third column
        sheet.showColumn(3);

        //Unhide the third row
        sheet.showRow(3);

        //Save the document
        wb.saveToFile("ShowRowsColumns.xlsx", ExcelVersion.Version2016);
    }
}

Hide Multiple Rows and Columns

Create a Workbook instance and load a sample Excel document using Workbook.loadFromFile() method.
Get a specified worksheet using Workbook.getWorksheets().get() method.
Hide multiple columns using Worksheet.hideColumns(int columnIndex, int columnCount)method.
Hide multiple rows using worksheet.hideRows(int rowIndex, int rowCount) method.
Save the document to file using Workbook.saveToFile() method.

import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;


public class HideMultiRowsColumns {
    public static void main(String[] args) throws Exception {

        //Load the sample document
        Workbook wb = new Workbook();
        wb.loadFromFile("Sample.xlsx ");

        //Get the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Hide multiple columns
        sheet.hideColumns(2,2);

        //Hide multiple rows
        sheet.hideRows(3,3);

        //Save the document
        wb.saveToFile("HideMultiRowsColumns.xlsx", ExcelVersion.Version2016);
    }
}

Show Multiple Rows and Columns

Create a Workbook instance and load a sample Excel document using Workbook.loadFromFile() method.
Get a specified worksheet using Workbook.getWorksheets().get() method.
Loop through the rows and find the hidden rows using Worksheet.getRowIsHide() method.
Show all hidden rows using Worksheet.showRow(i) method.
Save the document to file using Workbook.saveToFile() method.

import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;


public class ShowMultiRowsColumns {
    public static void main(String[] args) throws Exception {

        //Load the sample document
        Workbook wb = new Workbook();
        wb.loadFromFile("HideMultiRowsColumns.xlsx");

        //Get the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Traverse all the rows 
        for (int i = 1; i <= sheet.getLastRow(); i++) {

                //detect if the row is hidden
                if (sheet.getRowIsHide(i)) {

                    //Show the hidden rows
                    sheet.showRow(i);
                }
            }

        //Traverse the columns and show all the hidden columns
        for (int j = 1; j <= sheet.getLastColumn(); j++) {
            if (sheet.getColumnIsHide(j)) {
                sheet.showColumn(j);
            }

            //Save the document
            wb.saveToFile("ShowMultiRowsColumns.xlsx", ExcelVersion.Version2016);
        }
    }
}

Java Delete Blank Rows and Columns in Excel

E-iceblue Product Family — Tue, 28 Dec 2021 08:53:27 +0000

In this article, we will demonstrate how to delete blank rows and columns in Excel in Java applications by using Spire.XLS for Java. We can detect if the rows and columns is blank or not using the method Worksheet.getRows().isBlank() and Worksheet.getColumns().isBlank(). After that we can easily remove rows and columns from Excel worksheets programmatically using the method Worksheet.deleteRow(int) and Worksheet.deleteColumn(int).

Install Spire.XLS for Java

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.xls</artifactId>
        <version>4.12.2</version>
    </dependency>
</dependencies>

Delete Blank Rows in Excel using Java

The following are the steps to remove the blank rows in Excel:

Create a Workbook object and load the sample Excel document using Workbook.loadFromFile() method.
Get the desired worksheet using Workbook.getWorksheets().get() method.
Traverse the rows and determine if the rows is blank using Worksheet.getRows().isBlank() method.
Delete the blank rows using Worksheet.deleteRow(int) method.
Save the document to another file using Workbook.saveToFile() method.

import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;


public class RemoveBlankRows {
    public static void main(String[] args) throws Exception {

        //Load the sample document
        Workbook wb = new Workbook();
        wb.loadFromFile("Sample.xlsx ");

        //Get the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Loop through the rows
        for (int i = sheet.getLastRow(); i >= 1; i--)
        {
            //Detect if a row is blank
            if (sheet.getRows()[i-1].isBlank())
            {
                //Remove blank row
                sheet.deleteRow(i);
            }
        }


        //Save the document
        wb.saveToFile("DeleteBlankRowsAndColumns.xlsx", ExcelVersion.Version2016);


    }
}

Delete Blank Columns in Excel using Java

The following are the steps to remove the blank columns in Excel.

Create a Workbook object and load the sample Excel document using Workbook.loadFromFile() method.
Get the desired worksheet using Workbook.getWorksheets().get() method.
Traverse the columns and determine if the columns is blank using Worksheet.getColumns().isBlank() method.
Delete the blank rows using Worksheet.deleteColumn(int) method.
Save the document to another file using Workbook.saveToFile() method.


import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;


public class RemoveBlankColumns {
    public static void main(String[] args) throws Exception {

        //Load the sample document
        Workbook wb = new Workbook();
        wb.loadFromFile("Sample01.xlsx ");

        //Get the first worksheet
        Worksheet sheet = wb.getWorksheets().get(0);

        //Loop through the columns
        for (int i = sheet.getLastColumn(); i >= 1; i--)
        {
            //Detect if a column is blank
            if (sheet.getColumns()[i-1].isBlank())
            {
                //Remove blank column
                sheet.deleteColumn(i);
            }
        }

        //Save the document
        wb.saveToFile("DeleteBlankColumns.xlsx", ExcelVersion.Version2016);
    }
}

Group or Ungroup Rows and Columns in Excel in Java

E-iceblue Product Family — Wed, 22 Dec 2021 07:42:38 +0000

In Microsoft Excel, rows and columns can be grouped or ungrouped to analyze and summarize data. In this article, we will demonstrate how to group or ungroup rows and columns in Excel in Java using Spire.XLS for Java library.

Contents Summary:

Group Rows and Columns
Add Subtotals to a Range
Ungroup Rows and Columns

Add Dependencies

<repositories>    
    <repository>    
        <id>com.e-iceblue</id>    
        <name>e-iceblue</name>    
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>    
    </repository>    
</repositories>    
<dependencies>    
    <dependency>    
        <groupId>e-iceblue</groupId>    
        <artifactId>spire.xls</artifactId>    
        <version>4.12.2</version>    
    </dependency>    
</dependencies>

Group Rows and Columns

You can group rows and columns by using the groupByRows and groupByColumns methods of XlsWorksheet class. Both of the methods accept the following parameters:

int: the first row/column index to be grouped.
int: the last row/column index to be grouped.
boolean: indicates whether to show/hide the grouped data.

Note: You need to make sure that each column of the data that you want to group has a label in the first row (e.g., Region), contains similar facts in each column, and the range that you want to group has no blank rows or columns.

import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;

public class GroupRowsAndColumns {
    public static void main(String []args){

        //Create a Workbook instance
        Workbook workbook = new Workbook();
        //Load an Excel file
        workbook.loadFromFile("Report.xlsx");

        //Get the first worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        //Group specific rows
        sheet.groupByRows(2, 6, false);
       //Group specific columns
        sheet.groupByColumns(1, 3, false);

        //Save the result file
        workbook.saveToFile("GroupRowsAndColumns.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

Output:

Add Subtotals to a Range

You can insert subtotals and totals to quickly calculate rows of related data in a range by using the subtotal method of XlsWorksheet class. The method accepts the following parameters:

IXLSRange: the specific cell range.
int: the column index (zero-based) on which you wish to group data.
int[]: the list of column indexes (zero-based) on which the subtotals should be calculated.
SubtotalTypes: the function that you want to use to calculate the subtotals.
boolean: Indicates whether to replace existing subtotals.
boolean: Indicates whether to insert page breaks between groups.
boolean: Indicates whether to add summary rows below each group of detail rows.

import com.spire.xls.*;

public class AddSubtotalsToRange {
    public static void main(String []args){

        //Create a Workbook instance
        Workbook workbook = new Workbook();
        //Load an Excel file
        workbook.loadFromFile("Report.xlsx");

        //Get the first worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        //Specify the range that you wish to subtotal
        CellRange range = sheet.getCellRange("A2:C11");

        //Add subtotal to the range
        sheet.subtotal(range, 0, new int[] { 2 }, SubtotalTypes.Sum, true, false, true);

        //Save the result file
        workbook.saveToFile("AddSubtotal.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

Output:

Ungroup Rows and Columns

To ungroup rows and columns, you need to use the ungroupByRows and ungroupByColumns methods of XlsWorksheet class. Both of the methods accept the following parameters:

int: the first row/column index to be ungrouped.
int: the last row/column index to be ungrouped.

import com.spire.xls.CellRange;
import com.spire.xls.ExcelVersion;
import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;

public class UngroupRowsAndColumns {
    public static void main(String []args){

        //Create a Workbook instance
        Workbook workbook = new Workbook();
        //Load an Excel file
        workbook.loadFromFile("GroupRowsAndColumns.xlsx");

        //Get the first worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        //Ungroup specific rows
        sheet.ungroupByRows(2, 6);
       //Ungroup specific columns
        sheet.ungroupByColumns(1, 3);

        //Save the result file
        workbook.saveToFile("UnGroupRowsAndColumns.xlsx", ExcelVersion.Version2016);
        workbook.dispose();
    }
}

Output:

How to Indent a Paragraph in Word in Java

E-iceblue Product Family — Wed, 22 Dec 2021 04:00:25 +0000

In this article, we will demonstrate how to indent paragraphs in Word in Java applications using Spire.Doc for Java. Spire.Doc for Java offers ParagraphFormat.setLeftIndent(float value) method to set the paragraph left indents and ParagraphFormat.setRightIndent(float value) for right indents. The ParagraphFormat.setFirstLineIndent(float value) method can be used to set both hanging and first line indents. Negative value for this property is for the hanging indent and positive value for the first line indent of the paragraph.

Install Spire.Doc for Java

First of all, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's pom.xml file.

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.doc</artifactId>
        <version>4.12.7</version>
    </dependency>
</dependencies>

Using the code

The following are the steps to set paragraph indents in Word:

Create a Document instance.
Load a Word document using Document.loadFromFile() method.
Get the desired section by its index using Document.getSections.get() method.
Get the desired paragraph by index using Section.getParagraphs.get() method.
Get the ParagraphFormat object using Paragraph.getFormat() method.
Call the methods to set paragraph indents with the object.
Save the result document using Document.saveToFile() method.


import com.spire.doc.Document;
import com.spire.doc.FileFormat;
import com.spire.doc.Section;
import com.spire.doc.documents.Paragraph;
import com.spire.doc.formatting.ParagraphFormat;

public class Test {
    public static void main(String[] args) throws Exception {
        //Create a Document instance
        Document document= new Document();
        //Load a Word document
        document.loadFromFile("Sample.docx");

        //Get the first section
        Section section = document.getSections().get(0);

        //Get the first paragraph and set left indent, right indent
        Paragraph para = section.getParagraphs().get(0);
        ParagraphFormat format = para.getFormat();
        format.setLeftIndent(30);
        format.setRightIndent(50);

        //Get the second paragraph and set first line indent
        para = section.getParagraphs().get(1);
        format = para.getFormat();
        format.setFirstLineIndent(30);

        //Get the third paragraph and set hanging indent
        para = section.getParagraphs().get(2);
        format = para.getFormat();
        format.setFirstLineIndent(-30);

        //Save the result document
        document.saveToFile("SetParagraphIndents.docx", FileFormat.Docx_2013);
    }
}