Dans le monde basé sur les données d’aujourd’hui, la visualisation d’informations complexes à travers des diagrammes et des graphiques est devenue essentielle. Alors que Excel fournit de puissantes capacités de diagrammes, il y a de nombreux scénarios où vous devez extraire ces éléments visuels comme des images indépendantes:

  • Incorporer des graphiques dans les rapports et présentations
  • Introduire des visualisations dans les applications Web
  • Partager des informations sans distribuer l’intégralité des brochures
  • Créer des documents avec des illustrations graphiques
  • Gérer du contenu visuel dynamique pour les dashboards d’intelligence d’entreprise

Aspose.Cells pour .NET offre une solution robuste pour convertir programmatiquement les graphiques Excel en images de haute qualité sans nécessiter l’installation de Microsoft Excel.

Pourquoi choisir Aspose.Cells pour la conversion de graphique?

Les approches traditionnelles à l’automatisation d’Excel peuvent être problématiques dans les environnements de production en raison de:

  • Les vulnérabilités de sécurité
  • Les complexités d’exploitation
  • Les défis de licence
  • Les bouteilles de performance
  • Problèmes de stabilité

Aspose.Cells fournit une API dédiée spécifiquement conçue pour le traitement sur le côté du serveur des fichiers Excel, offrant une performance et une fiabilité supérieures.

Iniziare

Avant de tomber dans les exemples, assurez-vous que vous avez:

  • Téléchargé et installé Aspose.Celles pour .NET
  • Ajouter une référence à Aspose.Cells.dll Dans votre projet
  • Importer les espaces de nom nécessaires :
using Aspose.Cells;
using Aspose.Cells.Charts;
using Aspose.Cells.Rendering;

Charte de base pour la conversion d’image

Commençons par un exemple simple de la conversion de tous les diagrammes dans une feuille de travail en images en utilisant C# Excel Chart to Image:

// Load the Excel file containing charts
Workbook workbook = new Workbook("SalesReport.xlsx");

// Access the worksheet containing charts
Worksheet sheet = workbook.Worksheets[0];

// Initialize counter for unique filenames
int chartIndex = 1;

// Process each chart in the worksheet
foreach (Chart chart in sheet.Charts)
{
    // Define the output path for the image
    string outputPath = $"Chart_{chartIndex}.png";
    
    // Convert the chart to an image
    chart.ToImage(outputPath, ImageFormat.Png);
    
    Console.WriteLine($"Successfully converted chart {chartIndex} to {outputPath}");
    chartIndex++;
}

Améliorer la qualité de l’image avec des options personnalisées

Pour les applications professionnelles, vous devrez souvent contrôler la qualité et l’apparence des images exportées. Cela peut être atteint en utilisant les techniques Java Excel Chart to Image:

// Load the workbook containing charts
Workbook workbook = new Workbook("FinancialDashboard.xlsx");
Worksheet sheet = workbook.Worksheets["Performance Metrics"];

// Create image options with high resolution
ImageOrPrintOptions imageOptions = new ImageOrPrintOptions
{
    HorizontalResolution = 300,
    VerticalResolution = 300,
    ImageFormat = ImageFormat.Jpeg,
    Quality = 95 // Higher quality JPEG compression
};

// Access a specific chart (e.g., the first chart)
Chart revenueChart = sheet.Charts[0];

// Convert with custom options
revenueChart.ToImage("Revenue_Trends_HQ.jpg", imageOptions);

Conversion de plusieurs graphiques avec différents formats

Différents cas d’utilisation peuvent nécessiter différents formats d’image. Voici comment exporter des diagrammes à différents formats:

// Load the Excel workbook
Workbook workbook = new Workbook("QuarterlyReport.xlsx");
Worksheet sheet = workbook.Worksheets["Sales Analysis"];

// Initialize counter for unique filenames
int idx = 0;

// Process each chart with custom options for different formats
foreach (Chart chart in sheet.Charts)
{
    // Create image options
    ImageOrPrintOptions imgOpts = new ImageOrPrintOptions();
    
    // Configure different settings based on chart index
    switch (idx % 3)
    {
        case 0: // PNG format with transparency
            imgOpts.ImageFormat = ImageFormat.Png;
            chart.ToImage($"Chart_{idx}_transparent.png", imgOpts);
            break;
            
        case 1: // JPEG format with high quality
            imgOpts.ImageFormat = ImageFormat.Jpeg;
            imgOpts.Quality = 100;
            chart.ToImage($"Chart_{idx}_high_quality.jpg", imgOpts);
            break;
            
        case 2: // SVG format for vector graphics
            imgOpts.ImageFormat = ImageFormat.Svg;
            chart.ToImage($"Chart_{idx}_vector.svg", imgOpts);
            break;
    }
    
    ++idx;
}

Options de rendement de graphique avancée

Lorsque vous avez besoin de contrôle précis sur le processus de rendu, Aspose.Cells fournit des capacités de personnalisation étendues:

// Load the source workbook
Workbook workbook = new Workbook("MarketingAnalytics.xlsx");
Worksheet sheet = workbook.Worksheets["Campaign Performance"];

// Get reference to a specific chart
Chart campaignChart = sheet.Charts[0];

// Create advanced rendering options
ImageOrPrintOptions renderOptions = new ImageOrPrintOptions
{
    // Set high resolution for print-quality output
    HorizontalResolution = 600,
    VerticalResolution = 600,
    
    // Control image appearance
    ImageFormat = ImageFormat.Png,
    OnlyArea = false, // Include the entire chart area
    
    // Set custom dimensions (if needed)
    CustomPrintPageWidth = 800,
    CustomPrintPageHeight = 600,
    
    // Enable text rendering hints for smoother text
    TextRenderingHint = TextRenderingHint.AntiAlias,
    
    // Apply print settings from the workbook
    PrintingPage = PrintingPageType.Default
};

// Convert chart with advanced options
campaignChart.ToImage("Campaign_Performance_Print_Quality.png", renderOptions);

Graphiques de traitement de batch à partir de plusieurs feuilles de travail

Dans les applications d’entreprise, vous devrez peut-être traiter des diagrammes sur plusieurs feuilles de travail:

// Load the source Excel file
Workbook workbook = new Workbook("AnnualReport.xlsx");

// Create a directory for output images
string outputDir = "ChartImages";
Directory.CreateDirectory(outputDir);

// Process charts from all worksheets in the workbook
foreach (Worksheet sheet in workbook.Worksheets)
{
    // Skip worksheets without charts
    if (sheet.Charts.Count == 0)
        continue;
        
    Console.WriteLine($"Processing {sheet.Charts.Count} charts from worksheet '{sheet.Name}'");
    
    // Process each chart in the current worksheet
    for (int i = 0; i < sheet.Charts.Count; i++)
    {
        // Get the chart
        Chart chart = sheet.Charts[i];
        
        // Create a descriptive filename
        string sanitizedSheetName = string.Join("_", sheet.Name.Split(Path.GetInvalidFileNameChars()));
        string outputPath = Path.Combine(outputDir, $"{sanitizedSheetName}_Chart_{i+1}.png");
        
        // Define image options
        ImageOrPrintOptions imgOptions = new ImageOrPrintOptions
        {
            HorizontalResolution = 300,
            VerticalResolution = 300
        };
        
        // Convert and save the chart
        chart.ToImage(outputPath, imgOptions);
        
        Console.WriteLine($"  - Saved chart {i+1} to {outputPath}");
    }
}

Conversion des graphiques en SVG pour les applications Web

SVG (Scalable Vector Graphics) est un excellent format pour les applications Web, assurant que vos graphiques paraissent crisp à toute résolution:

// Load the workbook
Workbook workbook = new Workbook("WebDashboard.xlsx");
Worksheet sheet = workbook.Worksheets["Performance Metrics"];

// Configure SVG export options
ImageOrPrintOptions svgOptions = new ImageOrPrintOptions
{
    ImageFormat = ImageFormat.Svg,
    SaveFormat = SaveFormat.Svg
};

// Export all charts to SVG with viewBox attribute for responsive display
for (int i = 0; i < sheet.Charts.Count; i++)
{
    Chart chart = sheet.Charts[i];
    
    // Export with viewBox attribute
    chart.ToImage($"WebChart_{i+1}.svg", svgOptions);
}

Surveiller le progrès de la conversion pour les grands livres de travail

Lorsque vous traitez des livres de travail contenant de nombreux graphiques, il est utile de suivre le progrès de la conversion:

// Load a large workbook with many charts
Workbook workbook = new Workbook("EnterpriseReports.xlsx");

// Create a custom stream provider to monitor progress
class ChartConversionStreamProvider : IStreamProvider
{
    private int _totalCharts;
    private int _processedCharts = 0;
    
    public ChartConversionStreamProvider(int totalCharts)
    {
        _totalCharts = totalCharts;
    }
    
    public Stream GetStream(string chartName, StreamType streamType)
    {
        // Create output stream
        string outputPath = $"Chart_{chartName}.png";
        Stream stream = new FileStream(outputPath, FileMode.Create);
        
        // Update and report progress
        _processedCharts++;
        double progressPercentage = (_processedCharts / (double)_totalCharts) * 100;
        Console.WriteLine($"Converting chart {_processedCharts} of {_totalCharts}: {progressPercentage:F1}% complete");
        
        return stream;
    }
    
    public void CloseStream(Stream stream)
    {
        if (stream != null)
        {
            stream.Close();
        }
    }
}

// Count total charts across all worksheets
int totalCharts = 0;
foreach (Worksheet sheet in workbook.Worksheets)
{
    totalCharts += sheet.Charts.Count;
}

// Create stream provider and options
ChartConversionStreamProvider streamProvider = new ChartConversionStreamProvider(totalCharts);
ImageOrPrintOptions options = new ImageOrPrintOptions
{
    HorizontalResolution = 300,
    VerticalResolution = 300
};

// Process each chart with progress tracking
int chartIndex = 0;
foreach (Worksheet sheet in workbook.Worksheets)
{
    foreach (Chart chart in sheet.Charts)
    {
        // Generate unique chart name
        string chartName = $"{sheet.Name}_Chart_{chartIndex++}";
        
        // Convert using stream provider
        chart.ToImage(streamProvider.GetStream(chartName, StreamType.Output), options);
    }
}

Les meilleures pratiques pour la conversion à l’image

Pour obtenir des résultats optimaux lors de la conversion de graphiques Excel en images, considérez ces recommandations:

  • Résolution ajustée basée sur la finalité: Utilisez des résolutions plus élevées (300+ DPI) pour les matériaux d’impression et des résolutions inférieures pour l’affichage web.
  • Choisissez le bon format: Utilisez PNG pour les graphiques transparents, JPEG pour les photos et SVG pour les applications Web.
  • Test Différents paramètres de qualité: Équilibre la taille du fichier et la qualité de l’image, en particulier pour la compression JPEG.
  • Sanitez les noms de fichier: Lorsque vous générez des noms de fichier des noms de feuille de travail, supprimez les caractères invalides.
  • Implementation Progress Tracking: Pour les livres de travail avec de nombreux graphiques, fournir des commentaires sur les progrès aux utilisateurs.
  • Travaillez les ressources de manière appropriée: Prendre des flux proches et disposer des objets pour éviter les fuites de mémoire.

Conclusion

Aspose.Cells pour .NET fournit une solution puissante et flexible pour convertir les graphiques Excel à divers formats d’image de manière programmée. Que vous ayez besoin d’images à haute résolution pour les matériaux d’impression, les graphiques optimisées pour les applications web, ou SVGs vecteurs pour les concepts réactifs, Aspose.Cells fournit des résultats cohérents et de haute qualité sans nécessiter l’installation de Microsoft Excel.

En suivant les exemples et les meilleures pratiques décrits dans cet article, vous pouvez intégrer les capacités de conversion graphique à image dans vos applications .NET, améliorer vos flux de travail de visualisation de données et permettre le partage sans fil de visualisation basée sur Excel sur différentes plateformes et médias.

More in this category