À l'aide de java.awt.image.BufferedImage pour créer un enregistrement BITMAP BIFF8 prend beaucoup de temps-Y a-t-il une meilleure approche?

Comme souvent c'est simplement la stupidité du programmeur lui-même; -). En allemand, il y a un dicton: "Ne peut pas voir la forêt à cause des arbres.".

Obtenir simplement le {[2] } du BufferedImage une fois à l'extérieur des boucles au lieu de le faire à l'intérieur des boucles encore et encore augmente énormément la vitesse:

...
  // put the bytes R G B into the data; lines of the bitmap must be from bottom line to top line
  int bytes = 0;
  Raster raster = image.getData();
  for (short y = (short)(height - 1); y >= 0; y--) {
   for (short x = 0; x < width; x++) {
    int r = raster.getSample(x, y, 2);
    data.add(Byte.valueOf((byte)r));
    bytes++;
    int g = raster.getSample(x, y, 1);
    data.add(Byte.valueOf((byte)g));
    bytes++;
    int b = raster.getSample(x, y, 0);
    data.add(Byte.valueOf((byte)b));
    bytes++;
   } 
   // fill up x with 0 bytes up to multiple of 4
   for (int x = width * 3; x < widthBytesMultOf4; x++) {
    data.add(Byte.valueOf((byte)0));
    bytes++;
   }
  }
...

Mais l'indice de @Gagravarr dans son commentaire semble également intéressant.

2.4.19 BkHim

Le BkHim enregistrement spécifie les données d'image pour un fond de feuille (1)

Cf (2 octets): Un entier signé qui spécifie le format d'image. DOIT être une valeur de ce qui suit:

Valeur: 0x0009

Signification: Format Bitmap. Les données d'image sont stockées dans un format bitmap comme décrit dans [MSDN-BMP]

Valeur: 0x000E

Signification: Format natif. Les données d'image sont stockées dans le format natif d'une autre application et ne peuvent pas être directement transformés.

Cela ressemble à s'il est 0x000E les premiers octets au lieu de 0x0009 puis les octets d'image natifs (PNG, JPG, BMP, ...) pourrait être stocké directement. Vais essayer cela demain.

Eh bien, comme souvent seulement un effort futile avec les "documentations"de Microsoft. Le https://interoperability.blob.core.windows.net/files/MS-XLS/[MS-XLS]. pdf semble correct mais incomplet, du moins à la page 211: 2.4.19 Bkhim. Donc, utiliser 0x000E au lieu de {[5] } ne permettra pas simplement stockage d'un imageBlob natif.

, Mais aussi la description de 0x0009:

Format bitmap. Les données d'image sont stockées dans un format bitmap, comme décrit dans [MSDN-BMP]

Seulement des liens vers une description incomplète du type de bitmap à utiliser ici. Rien sur la structure d'en-tête au début et les octets de pixels de la ligne du bas à la ligne du haut. Et aussi rien sur la nécessité d'aligner la taille de chaque ligne sur des multiples de 4 en insérant zéro octets après le dernier pixel. Mais sans le savoir, même en utilisant un bitmap 0x0009 ne fonctionnera pas.

Lorsque je mets n'importe quel type d'image d'arrière-plan dans une feuille de calcul dans un fichier *.xls en utilisant l'interface graphique de Excel, puis que je regarde ce fichier en utilisant un vidage hexadécimal, cela ressemble toujours à:

0xe900SSSS09000100SSSSSSSS0c000000WWWWHHHH01001800PPP...

Où S signifie taille, W signifie largeur, H signifie hauteur et P signifie pixel octet.

Ceci est indépendant du fait que je mets un BMP, JPG ou PNG comme image d'arrière-plan dans une feuille de calcul. Toujours ce type spécial de données BMP est utilisé.

Alors ce qu'OpenOffice a reconnu en utilisant la rétro-ingénierie dans https://www.openoffice.org/sc/excelfileformat.pdf est plus utile que la "documentation" de Microsoft.

Donc, le code suivant pour mettre l'image d'arrière-plan dans HSSFSheet fonctionne pour moi testé avec plusieurs types de fichiers d'image différents (BMP, PNG, JPG).

A également changé en utilisant List<Byte> data en byte[] data. Donc org.Apache.pi.hssf.dossier.ContinueRecord peut être utilisé directement et ne doit pas être recréé.

import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ByteArrayOutputStream;

import org.apache.poi.hssf.usermodel.*;

import org.apache.poi.hssf.record.RecordBase;
import org.apache.poi.hssf.record.StandardRecord;
import org.apache.poi.hssf.record.ContinueRecord;
import org.apache.poi.hssf.model.InternalSheet;

import org.apache.poi.util.LittleEndianOutput;

import java.lang.reflect.Field;

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;

import java.awt.image.BufferedImage;
import java.awt.image.Raster;
import java.awt.Graphics2D;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import javax.imageio.ImageIO;

public class CreateExcelHSSFSheetBackgroundBMP {

 static byte[] getBackgroundBitmapData(String filePath) throws Exception {

  // see https://www.openoffice.org/sc/excelfileformat.pdf - 5.6 BITMAP
  // and https://interoperability.blob.core.windows.net/files/MS-XLS/[MS-XLS].pdf - 2.4.19 BkHim

  // get file byte data in type BufferedImage.TYPE_3BYTE_BGR
  BufferedImage in = ImageIO.read(new FileInputStream(filePath));
  BufferedImage image = new BufferedImage(in.getWidth(), in.getHeight(), BufferedImage.TYPE_3BYTE_BGR);
  Graphics2D graphics = image.createGraphics();
  graphics.drawImage(in, null, 0, 0);
  graphics.dispose();

  short width = (short)image.getWidth();
  short height = (short)image.getHeight();

  // each pixel has 3 bytes but the width bytes must be filled up to multiple of 4
  int widthBytesMultOf4 = (int)((width * 3 + 3) / 4 * 4);

  // size 12 bytes (additional headers, see below) + picture bytes
  int size = 12 + height * widthBytesMultOf4;

  // create the header section
  ByteBuffer headers = ByteBuffer.allocate(20);
  headers.order(ByteOrder.LITTLE_ENDIAN);
  headers.putShort((short)0x09); // 0x0009 = signed integer that specifies the image format BMP
  headers.putShort((short)0x01); // reserved (2 bytes): MUST be 0x0001
  headers.putInt(size); // signed integer that specifies the size of imageBlob in bytes
  // BMP header section:
  headers.putInt(0x0C); // length 0x0C = 12 bytes
  headers.putShort(width); // pixels width
  headers.putShort(height); // pixels heigth
  headers.putShort((short)0x01); // number of planes: always 1
  headers.putShort((short)0x18); // color depth 0x018 = 24 bit

  //create data ByteArrayOutputStream
  ByteArrayOutputStream data = new ByteArrayOutputStream();

  // write headers section
  data.write(headers.array());

  // put the bytes R G B into the data; lines of the bitmap must be from bottom line to top line
  Raster raster = image.getData();
  for (short y = (short)(height - 1); y >= 0; y--) {
   for (short x = 0; x < width; x++) {
    int r = raster.getSample(x, y, 2);
    data.write((byte)r);
    int g = raster.getSample(x, y, 1);
    data.write((byte)g);
    int b = raster.getSample(x, y, 0);
    data.write((byte)b);
   } 
   // fill up x with 0 bytes up to multiple of 4
   for (int x = width * 3; x < widthBytesMultOf4; x++) {
    data.write((byte)0);
   }
  }

  return data.toByteArray();
 }

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

  HSSFWorkbook workbook = new HSSFWorkbook();
  HSSFSheet sheet = workbook.createSheet("Sheet1");
  sheet = workbook.createSheet("Sheet2"); // this sheet gets the background image set

  // we need the binary records of the sheet
  // get InternalSheet
  Field _sheet = HSSFSheet.class.getDeclaredField("_sheet");
  _sheet.setAccessible(true); 
  InternalSheet internalsheet = (InternalSheet)_sheet.get(sheet); 

  // get List of RecordBase
  Field _records = InternalSheet.class.getDeclaredField("_records");
  _records.setAccessible(true);
  @SuppressWarnings("unchecked") 
  List<RecordBase> records = (List<RecordBase>)_records.get(internalsheet);

  // get bytes of the image file
  byte[] data = getBackgroundBitmapData("dummyText.png"); //PNG must not have transparency

  // do creating BitmapRecord and ContinueRecords from the data in parts of 8220 bytes
  BitmapRecord bitmapRecord = null;
  List<ContinueRecord> continueRecords = new ArrayList<ContinueRecord>();
  int bytes = 0;
  if (data.length > 8220) {
   bitmapRecord = new BitmapRecord(Arrays.copyOfRange(data, 0, 8220));
   bytes = 8220;
   while (bytes < data.length) {
    if ((bytes + 8220) < data.length) {
     continueRecords.add(new ContinueRecord(Arrays.copyOfRange(data, bytes, bytes + 8220)));
     bytes += 8220;
    } else {
     continueRecords.add(new ContinueRecord(Arrays.copyOfRange(data, bytes, data.length)));
     break;
    }
   }
  } else {
   bitmapRecord = new BitmapRecord(data);
  }

  // add the records after PageSettingsBlock
  int i = 0;
  for (RecordBase r : records) {
   if (r instanceof org.apache.poi.hssf.record.aggregates.PageSettingsBlock) {
    break;
   }
   i++;
  }
  records.add(++i, bitmapRecord);
  for (ContinueRecord continueRecord : continueRecords) {
   records.add(++i, continueRecord);  
  }

  // debug output
  for (RecordBase r : internalsheet.getRecords()) {
   System.out.println(r.getClass());
  }

  // write out workbook
  FileOutputStream out = new FileOutputStream("CreateExcelHSSFSheetBackgroundBMP.xls");
  workbook.write(out);
  workbook.close();
  out.close();

 }

 static class BitmapRecord extends StandardRecord {

  // see https://www.openoffice.org/sc/excelfileformat.pdf - 5.6 BITMAP
  // and https://interoperability.blob.core.windows.net/files/MS-XLS/[MS-XLS].pdf - 2.4.19 BkHim

  byte[] data;

  BitmapRecord(byte[] data) {
   this.data = data;
  }

  public int getDataSize() { 
   return data.length; 
  }

  public short getSid() {
   return (short)0x00E9;
  }

  public void serialize(LittleEndianOutput out) {
   out.write(data);
  }
 }

}