ich möchte aus einem 3d array z.B. arraySat[1000][1000][36] möglichst schnell ein Bitmap erstellen. Mit Canvas->Pixels ist das sehr langsam. Habe gelesen, dass das ganze mit Scanline deutlich schneller funktionieren soll, leider ergibt sich bei mir daraus kein Geschwindigkeitsvorteil. Habe ich etwas falsch gemacht bei der Anwendung von Scanline. Gibt es eine Möglichkeit ein Array in einem Zug ohne Schleife in ein Bitmap zu transformieren.

MFG

Marc

Graphics::TBitmap *bmp_array = new Graphics::TBitmap();
bmp_array->Height      = zeile;
bmp_array->Width       = spalte;
bmp_array->PixelFormat = pf24bit;
RGBTRIPLE* t;

  for(int y = 0; y < zeile; y++)
  {
    t = (RGBTRIPLE*)bmp_array->ScanLine[y];
    for(int x = 0; x < spalte; x++)
    {
      t->rgbtBlue = (BYTE)arraySat[y][x][band1];
      t->rgbtGreen = (BYTE)arraySat[y][x][band2];
      t->rgbtRed = (BYTE)arraySat[y][x][band3];
      t++;
    }
  }

Bye, TGGC (Dem beste BdT)

Unabhängig von Scanline erzielt man bei solchen Vorgängen auf Vektoren oft erhebliche Gewinne, wenn man die Loops "unrollt", um den Compiler bei der Parallelisierung zu unterstützen. Also in etwa:
[cpp]
u=t+1;
for(int x = 0; x < spalte; x=x+2 )
{
t->rgbtBlue = (BYTE)arraySat[y][x][band1];
t->rgbtGreen = (BYTE)arraySat[y][x][band2];
t->rgbtRed = (BYTE)arraySat[y][x][band3];
u->rgbtBlue = (BYTE)arraySat[y][x+1][band1];
u->rgbtGreen = (BYTE)arraySat[y][x+1][band2];
u->rgbtRed = (BYTE)arraySat[y][x+1][band3];
t=t+2;
u=u+2;
}
// natürlich vorher gucken, ob "spalte" gerade Zahl ist, usw.
[/cpp]
Das wäre ein "Unroll-Faktor" von 2, weil pro Schleifendurchlauf zwei Vektor-Elemente bearbeitet werden. Zumindest bei größeren Feldern solltest du einen erheblichen Unterschied messen können. Probier' einfach mal unterschiedliche Unroll-Faktoren aus.

Google mal nach loop unrolling. Wichtig ist dabei, dass die Operationen innerhalb der Schleife voneinander unabhängig sind (und vom Compiler auch so erkannt werden), so dass sie gefahrlos parallelisiert werden können.

Na ja. Das können andere sicherlich besser erklären als ich.

so komme gerade vom Umzug wieder und habe das mal schnell probiert mit den Unroll-Faktoren. Hat leider bisher noch keinen Geschwindigkeitsvorteil gebracht. Werde mal ein wenig zu dem Thema Googlen.

Vielleicht hat ja noch jemand einen anderen Vorschlag.

Grüße Marc

// Bereitstellen des PLatzes fuer die m int-Zeiger ( = zeilen)
matrix3db = new unsigned char **[zeile];
for (i_image = 0; i_image < zeile; i_image++)
  {
    // Bereitstellen des Platzes für die n Spalten der i.ten zeile
    matrix3db[i_image] = new unsigned char*[spalte];
    }

  for (i_image2 = 0; i_image2 < zeile; i_image2++)
  { for (i_image3 = 0; i_image3 < spalte; i_image3++)
  {

    // Bereitstellen des Platzes für dim
    matrix3db[i_image2][i_image3] = new unsigned char[dim];

Wenn ich jetzt einzelne Bänder (z. B. [zeile][spalte][2], [zeile][spalte][4] ) daraus per memcpy kopieren möchte funktioniert das wohl nicht. Sprich, ich müßte meine Speicherfreigabe ändern und das ganze linear einlesen. Das wäre aber sehr unbefriedigend, derweilen meine ganzen anderen Routinen und die Daten auf diese Speicherverwaltung ausgerichtet sind.
oder gibt es eine Möglichkeit auch auf den wie oben beschriebenen Speicherblock den memcpy Befehl auszuführen

Grüße Marc

du kannst hier immer nur die 3. dimension per memcpy herumkopieren. desweiteren solltest du auf zeiger-arithmetik umsteigen um die verwendung der index-operatoren ([]) zu verhindern.