Comment convertir les graphiques et les feuilles Excel en images PNG

Cet article montre comment convertir les graphiques et les feuilles de travail d’Excel en images PNG en utilisant l’Aspose.Cells LowCode ImageConverter dans les applications .NET.L’ImageConverster fournit une approche simplifiée pour exporter les éléments visuels de Excel en tant qu’images de haute qualité sans nécessiter un codage étendu ou une connaissance approfondie des structures intérieures Excel.

Problème du monde réel

Les concepteurs de rapports et les analystes d’affaires doivent souvent incorporer des visualisations basées sur Excel dans des présentations, des documents et des applications Web. En prenant manuellement des captures d’écran ou en utilisant des bibliothèques complexes de manipulation des images, la qualité inconsistante, le formatage perdu et le développement significatif résultent.

Vue de la solution

Avec Aspose.Cells LowCode ImageConverter, nous pouvons résoudre ce défi efficacement avec un code minimum. Cette solution est idéale pour les concepteurs de rapports et les analystes d’affaires qui ont besoin de générer programmatiquement des actifs visuels de haute qualité des données Excel tout en préservant le formatage et la fidélité visuelle.

Principaux

Avant de mettre en œuvre la solution, assurez-vous que vous avez :

Visual Studio 2019 ou ultérieur
.NET 6.0 ou ultérieur (compatible avec le framework 4.6.2+)
Aspose.Cells pour le package .NET installé via NuGet
Comprendre la programmation C#


PM> Install-Package Aspose.Cells

La mise en œuvre étape par étape

Étape 1 : Installer et configurer Aspose.Cells

Ajouter le paquet Aspose.Cells à votre projet et inclure les espaces de nom nécessaires:

using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;
using System.IO;

Étape 2 : Préparez vos données d’entrée

Identifier le fichier Excel contenant les diagrammes ou les feuilles de travail que vous voulez convertir en images PNG. Assurez-vous que le dossier existe et est accessible à partir de votre application:

// Define the path to your Excel file
string excelFilePath = "reports/quarterly_sales.xlsx";

// Ensure the directory for output exists
Directory.CreateDirectory("result");

Étape 3 : Configurez les options ImageConverter

Configurez les options pour le processus ImageConverter selon vos besoins:

// Basic usage - convert the entire workbook
ImageConverter.Process(excelFilePath, "result/BasicOutput.png");

// Advanced configuration
LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
loadOptions.InputFile = excelFilePath;

LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
imageOptions.Quality = 100; // Set the quality of the output image
imageOptions.OnePagePerSheet = true; // Each sheet on a separate image
saveOptions.ImageOptions = imageOptions;

Étape 4 : Exécuter le processus ImageConverter

Exécuter l’opération ImageConverter avec les options configurées :

// Basic execution
ImageConverter.Process(loadOptions, saveOptions);

// Advanced execution with custom file naming
LowCodeSaveOptionsProviderOfPlaceHolders fileNameProvider = new LowCodeSaveOptionsProviderOfPlaceHolders(
    "result/Chart${SheetIndexPrefix}${SheetIndex}_${SplitPartIndex}.png");
fileNameProvider.SheetIndexOffset = 1;
fileNameProvider.SheetIndexPrefix = "S";
fileNameProvider.SplitPartIndexOffset = 1;

ImageConverter.Process(loadOptions, saveOptions, fileNameProvider);

Étape 5 : Gérer la sortie

Traitez et utilisez les images PNG générées comme nécessaire pour votre application:

// Verify the output files exist
if (File.Exists("result/ChartS1_1.png"))
{
    Console.WriteLine("Chart image successfully created!");
    
    // Implement your logic to use the image files
    // For example: Copy to a web server directory
    // File.Copy("result/ChartS1_1.png", "wwwroot/images/chart1.png");
}

Étape 6 : Traitement de l’erreur

Ajoutez le bon traitement d’erreur pour assurer un fonctionnement robuste :

try
{
    // Configure load options
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
    loadOptions.InputFile = excelFilePath;
    
    // Configure save options
    LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
    ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
    imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
    saveOptions.ImageOptions = imageOptions;
    
    // Execute conversion
    ImageConverter.Process(loadOptions, saveOptions);
    
    Console.WriteLine("Conversion completed successfully.");
}
catch (Exception ex)
{
    // Error handling and logging
    Console.WriteLine($"Error during conversion: {ex.Message}");
    // Log the error to your logging system
    // Consider implementing retry logic for transient issues
}

Étape 7 : Optimiser les performances

Considérons ces techniques d’optimisation pour les environnements de production:

Utilisez les flux de mémoire pour le traitement de volume élevé pour éviter l’excès de fichier I/O
Implémentation du traitement parallèle pour plusieurs diagrammes ou feuilles de travail
Ajuster les paramètres de qualité d’image pour l’équilibre approprié entre la qualité et la taille du fichier

// Using memory streams for programmatic use without file I/O
using (MemoryStream outputStream = new MemoryStream())
{
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
    loadOptions.InputFile = excelFilePath;
    
    LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
    ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
    imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
    
    // For web use, might want lower quality/size
    imageOptions.Quality = 85;
    saveOptions.ImageOptions = imageOptions;
    saveOptions.OutputStream = outputStream;
    
    ImageConverter.Process(loadOptions, saveOptions);
    
    // Use the stream directly (e.g., with web responses)
    byte[] imageBytes = outputStream.ToArray();
    
    // Example: save to file from memory stream
    File.WriteAllBytes("result/OptimizedChart.png", imageBytes);
}

Étape 8: Exemple complet de la mise en œuvre

Voici un exemple de travail complet qui démontre l’ensemble du processus:

using System;
using System.IO;
using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;

namespace ExcelChartToPngConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // Set up directories
                Directory.CreateDirectory("result");
                
                // Define source Excel file
                string excelFilePath = "quarterly_sales.xlsx";
                
                Console.WriteLine("Starting Excel chart conversion...");
                
                // Basic conversion - entire workbook
                ImageConverter.Process(excelFilePath, "result/FullWorkbook.png");
                
                // Advanced conversion with options
                LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
                loadOptions.InputFile = excelFilePath;
                
                LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
                ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
                imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
                imageOptions.Quality = 100;
                imageOptions.OnePagePerSheet = true;
                saveOptions.ImageOptions = imageOptions;
                
                // Custom file naming pattern for multi-sheet output
                LowCodeSaveOptionsProviderOfPlaceHolders fileNameProvider = 
                    new LowCodeSaveOptionsProviderOfPlaceHolders(
                        "result/Report${SheetIndexPrefix}${SheetIndex}_${SplitPartIndex}.png");
                fileNameProvider.SheetIndexOffset = 1;
                fileNameProvider.SheetIndexPrefix = "S";
                fileNameProvider.SplitPartIndexOffset = 1;
                
                // Execute conversion with custom naming
                ImageConverter.Process(loadOptions, saveOptions, fileNameProvider);
                
                // For specific sheet only conversion
                saveOptions = new LowCodeImageSaveOptions();
                imageOptions = new ImageOrPrintOptions();
                imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
                imageOptions.PageIndex = 0; // First sheet only
                saveOptions.ImageOptions = imageOptions;
                saveOptions.OutputFile = "result/FirstSheetOnly.png";
                
                ImageConverter.Process(loadOptions, saveOptions);
                
                Console.WriteLine("Conversion completed successfully!");
                Console.WriteLine("Output files located in 'result' directory.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error occurred: {ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
        }
    }
}

Utiliser les cas et les applications

Systèmes d’information entrepreneuriale

Les analystes financiers peuvent générer automatiquement des actifs visuels des rapports Excel pour être inclus dans les présentations exécutives ou les panneaux de bord. Cela éliminera la prise manuelle d’écran et assure des visualisations cohérentes et de haute qualité qui représentent exactement les données source.

Les flux de travail d’intégration des données

Les flux de travail d’intégration peuvent automatiquement convertir les graphiques basés sur Excel en formats d’image pour être inclus dans les rapports PDF, les portails Web ou les notifications par courrier électronique.

Traitement automatique de documents

Les systèmes de génération de documents peuvent programmatiquement extraire des diagrammes et des visualisations des ouvrages Excel pour créer des rapports professionnels qui combinent les données, le texte et les éléments visuels.

Défis communs et solutions

Défi 1 : Maintenir la qualité de l’image

Solution: Configurez les ImageOrPrintOptions avec les paramètres de qualité et de résolution appropriés pour assurer une performance optimale.Pour les présentations et les matériaux imprimés, utilisez des réglages de la qualité de 90 ou supérieurs et considérez l’adaptation de réglements DPI en fonction de votre utilisation prévue.

Défi 2 : traiter les grandes feuilles de travail

Solution: Utilisez les propriétés ImageOrPrintOptions.PageIndex et PageCount pour traiter des portions spécifiques de grandes feuilles de travail.

Défi 3 : Rendering incohérent autour des environnements

Solution: Assurez-vous que les caractères utilisés dans le fichier Excel sont disponibles sur le serveur, ou utilisez les paramètres de remplacement des fonctions dans Aspose.Cells. Testez en profondeur dans différents environnements de déploiement et considérez l’intégration des fonts nécessaires dans votre application.

Considérations de performance

Utilisez les flux de mémoire au lieu de fichiers I/O lors de la conversion de plusieurs images dans un processus de batch
Pour les environnements multi-triés, mettre en œuvre des mécanismes de localisation appropriés lors de l’accès aux ressources partagées
Considérez la taille et la complexité des feuilles lors de la configuration des options de qualité – une plus grande complexity nécessite plus de ressources de traitement

Migliori pratiche

Implémentation de mécanismes de caching pour les diagrammes fréquemment accessibles pour éviter les conversions répétées
Créer une convention de nom systématique pour les fichiers de sortie pour suivre la source de chaque image
Inclure les métadonnées dans la catégorie de sortie d’image pour maintenir la traçabilité de retour aux fichiers source Excel
Valider les fichiers d’entrée Excel avant le traitement pour s’assurer qu’ils contiennent les graphiques et les données attendues
Logage de mise en œuvre pour suivre les conversions réussies et tous les problèmes qui surviennent pendant le traitement

Scénarios avancés

Pour des exigences plus complexes, considérez ces applications avancées :

Scénario 1 : extraire uniquement des graphiques spécifiques d’une feuille de travail

using Aspose.Cells;
using Aspose.Cells.Charts;
using Aspose.Cells.Drawing;
using System.IO;

// Load the workbook
Workbook workbook = new Workbook("reports/charts.xlsx");

// Get the first worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Process each chart in the worksheet
for (int i = 0; i < worksheet.Charts.Count; i++)
{
    Chart chart = worksheet.Charts[i];
    
    // Save only specific charts based on title or other properties
    if (chart.Title.Text.Contains("Revenue"))
    {
        // Create image for this specific chart
        chart.ToImage("result/revenue_chart_" + i + ".png", new ImageOrPrintOptions
        {
            ImageType = ImageType.Png,
            HorizontalResolution = 300,
            VerticalResolution = 300
        });
    }
}

Scénario 2: Créer une image Dashboard multi-charts

using Aspose.Cells;
using Aspose.Cells.Drawing;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

// Load the workbook containing charts
Workbook workbook = new Workbook("reports/dashboard_data.xlsx");

// Create a bitmap to serve as the dashboard canvas
using (Bitmap dashboardImage = new Bitmap(1200, 800))
{
    using (Graphics g = Graphics.FromImage(dashboardImage))
    {
        // Set white background
        g.Clear(Color.White);
        
        // Draw title
        using (Font titleFont = new Font("Arial", 18, FontStyle.Bold))
        {
            g.DrawString("Q2 2025 Performance Dashboard", titleFont, 
                Brushes.DarkBlue, new PointF(400, 30));
        }
        
        // Extract and place charts
        int yPosition = 100;
        for (int sheetIndex = 0; sheetIndex < 3; sheetIndex++)
        {
            // Get specific worksheet with chart
            Worksheet sheet = workbook.Worksheets[sheetIndex];
            
            if (sheet.Charts.Count > 0)
            {
                // Convert chart to image
                MemoryStream chartStream = new MemoryStream();
                sheet.Charts[0].ToImage(chartStream, new ImageOrPrintOptions
                {
                    ImageType = ImageType.Png,
                    HorizontalResolution = 150,
                    VerticalResolution = 150
                });
                
                // Load chart image
                using (Bitmap chartImage = new Bitmap(chartStream))
                {
                    // Position chart on dashboard
                    g.DrawImage(chartImage, new Rectangle(50, yPosition, 500, 300));
                    yPosition += 320;
                }
            }
        }
        
        // Save the composite dashboard image
        dashboardImage.Save("result/complete_dashboard.png", ImageFormat.Png);
    }
}

Conclusion

En implémentant Aspose.Cells LowCode ImageConverter, vous pouvez efficacement convertir les graphiques Excel et les feuilles de travail en images PNG de haute qualité et simplifier la création d’actifs visuels pour les rapports et présentations. Cette approche réduit considérablement le temps de développement et l’effort manuel tout en préservant la fidélité visuelle et la cohérence du formatage.

Pour plus d’informations et de exemples supplémentaires, consultez le Aspose.Cells.LowCode API de référence .