Ich habe wie in der FAQ beschrieben den BCB eingestellt um eine Standalone EXE zu erzeugen, also eine die auch auf anderen Systemen läuft die nicht BCB inst. haben. Soweit ist das auch kein Problem ABER: Mein Programm macht folgendes es läd ein bmp Bild berechnet einen Filter darauf und zeigt das ganze wieder an. Wenn ich das Programm nun so kompiliere das es nur auf BCB Systemen läuft funktioniert alles 1A aber wenn ich es so comp. das es auf anderen Systemen läuft wird das Ergebnis ganz komisch Grün/Gelb ????? Irgendwelche Ideen ? Danke !

Edit:
Bitte aussagekräftige Überschriften wählen. Danke!

EDIT:

The OS schrieb:

Um in BCB Gif's zu laden, braucht man teure Lizenzen

Plemm Plemm?

Wer ist hier 'Plemm Plemm'? AFAIK liegt ein Patent auf dem GIF-Algorithmus. Um GIFs zu verwenden benötigt man also auch die entsprechende Lizenz.

ZeroooO:
Ohne mehr Informationen über das Entwicklungssystem und über den/die Testrechner und ggf. Details der Implementierung bzw. Anwendung deines Filters wird dir kaum jemand helfen können.

Spontan fallen mir als potentielle Fehlerquellen ein:
Andere Farbtiefe auf dem zweiten Rechner.
Falsches Pixelformat in TBitmap angegeben.
Rechenfehler in Routine.
Probleme mit Grafikkartentreiber.

Übrigens ist die Verwendung von Scanline um ein vielfaches schneller als Canvas[x,y].

Schau mal in die Onlinehilfe (aber Vorsicht, im Beispiel dort wird mit Byte* für den Zugriff auf Scanline gearbeitet. Das funktioniert aber nur bei Pixelformat pf8Bit. Für 16 bit mußt Du Word* nehmen, für 24 bit RGB*).

Es ist mit Sicherheit kein Einstellungsproblem für Stand-Alone-Exes! Das Problem ist in der Verwendung von TBitamp, respektive dem Canvas zu suchen.

Zero.. kann man die Header Datei nachliefern, dann können wir es ausprobieren.

@Zero..:
In der Zwischenzeit kannst Du versuchsweise immer nur Einstellung ändern, um festzustellen, ob sich das an einer einzelnen Einstellung fest machen läßt.

Wenn man sich mal ansieht was in den Canvas reingeschrieben wird:
mit ohne Laufzeitpackeges
0x00736E6F 0x00067463 Wert an identischer Canvasposition!
0x003A3939 0x00033A3F

interessant ist:
0x00000100 0x00000100 Werte identisch!!
0x00000600 0x00000600
Offensichtlich werden alle Werte unter 0x600 mit und ohne LZP identisch berechnet.

2. Das kann ja nicht gutgehen:

int Matrix[10];

...

    for (int k=0;k<pBitmap->Height;k++) {
...
      for (int n=0;n<pBitmap->Width;n++) {
...
        for (int y=NowY;y<k+3;y++) {
          for (int x=NowX;x<n+3;x++) {

            Matrix[j]=Canvas->Pixels[x][y];                                                 // Get 3x3 Pixels

            j=j+1;
          }
        }
      }
    }

wie groß ist Matrix und wie groß wird j?

zu 2. Matrix sollte 9 (3*3) Werte beinhalten, dementsprechend sollte (da es funktuioniert geh ich schon davon aus das dem so ist) j auch max 9 werden.
Es geht darum bei jedem Schleifen Durchlauf einen die RGB Werte von 9 Pixeln in einem 3x3 Block auszulesen dafür wird mit den schleifen k + n das bild von links nach rechts und oben nach unten in 3 Pixel breiten Zeilen ausgelesen und die Werte von einem Block (3x3) werden in Matrix abgelegt und nachdem sie bearbeitet und ausgegeben wurden wird ihr Inhalt mit dem nächsten Block überschrieben.

Wenn man sich mal ansieht was in den Canvas reingeschrieben wird:

mit          ohne Laufzeitpackeges
0x00736E6F   0x00067463  Wert an identischer Canvasposition!
0x003A3939   0x00033A3F

Hast Du denn mittlerweile mal versucht nachzuvollziehen, wie diese Unteschiedlichen Werte zustande kommen? Ein möglicher Weg wäre sich mal alle wichtigen Werte in eine StringList zu schreiben (jeweils mit und ohne Laufzeitpackes), auf Festplatte zu speichern und zu vergleichen. Dann hättest Du zumindest einen Anhaltspunkt, wo im Source zu suchen ist. Ach ja, ein bißchen Ordnung (Einrücken) könnte der Source wirklich vertragen, dass ist so absolut unleserlich.

Außerdem müchte ich noch mal auf Graphics::TBitmap->Scanline hinweisen. Auch hiermit kannst Du die einzelnen Pixel auslesen und schreiben. Das ist ca. 10 mal schneller als über Canvas[x][y].

globale Variablen:
ymaxorg und xmaxorg sind int und geben die Größe des Originalbitmaps an
Imagedata ist ein Array aus Byte, in der Größe des Bitmaps. Dieses Array wird, beim Öffnen der Datei, mit den Original-Bitmappixeldaten gefüllt.
BitmapShow (Graphics::TBitmap) nimmt das auszugebende Bild auf
bmp_rotate gibt nur an, um wieviel Grad das Bild gedreht wird.

void __fastcall TFormJPEGViewer::RotateBitmap(void)
{

	int ymaxrot;
	int xmaxrot;

	if (bmp_rotate == 2 || bmp_rotate == 0)
	{
		ymaxrot = ymaxorg;
		xmaxrot = xmaxorg;
	}
	else
	{
		ymaxrot = xmaxorg;
		xmaxrot = ymaxorg;
	}

	BitmapShow->Width = xmaxrot;
	BitmapShow->Height = ymaxrot;

	Byte* slRotated;
	pImagedata = Imagedata;

	if (bmp_rotate == 0) // 0° gedreht
	{
		for (int y = ymaxrot - 1; y >= 0; y--)
		{
			slRotated = (Byte*) BitmapShow->ScanLine[y];
			for (int x = xmaxrot - 1; x >= 0; x--)
			{
				*slRotated = *pImagedata;
				slRotated++;
				pImagedata++;
			}
		}
	}

	if (bmp_rotate == 2) // 180° gedreht
	{

		for (int y = 0; y < ymaxrot; y++)
		{
			slRotated = (Byte*) BitmapShow->ScanLine[y];
			slRotated += xmaxrot - 1;
			for (int x = 0; x < xmaxrot; x++)
			{
				*slRotated = *pImagedata;
				slRotated--;
				pImagedata++;
			}
		}
	}

if (bmp_rotate == 3) // 270° gedreht
 {
  for (int y = ymaxrot - 1; y >= 0; y--)
  {
   slRotated = (Byte*) BitmapShow->ScanLine[y];
   slRotated += xmaxrot - 1;
   for (int x = 0; x < xmaxrot; x++)
   {
    *slRotated = Imagedata[ymaxrot - 1 - y + (x * xmaxorg)];
    slRotated--;
   }
  }
 }

 if (bmp_rotate == 1) // 90° gedreht
 {
  for (int y = 0; y < ymaxrot; y++)
  {
   slRotated = (Byte*) BitmapShow->ScanLine[y];
   for (int x = 0; x < xmaxrot; x++)
   {
    *slRotated = Imagedata[y + (x * xmaxorg)];
    slRotated++;
   }
  }
 }
	bmp_rotate_old = bmp_rotate;
}

Schau Dir mal den Abschnitt um 0° drehen an. Dort wird aus dem im Arbeitsspeicher hinterlegten Daten das Bitmap unverändert wieder hergestellt.

*slRotated = *pImagedata

Hiermit wird ein Byte aus dem Array in die Scanline geschrieben. Kannst also den Werte aus *pImagedata einlesen (ersetzt das Lesen von Canvas->Pixel[x][y]) umrechnen und ín *slRotated reischreiben (ersetzt das Schreiben von Canvas->Pixel[x][y]).

Ich kann Dir das Testprojekt, aus dem diese Funktion stammt am Montag mal zum Download bereitstellen, oder zumailen.