Ein Bild Zerlegen

[Christian18]

Hallo,

ich habe eine Grafik und die soll in Raster eingeteilt werden. Also ich will eine kleine Routine schreiben, womit ich ein Bild öffne und dann soll die Routine das Bild in 10 mal 10 pixel bilder zerlegen. ist das möglich??? wenn ja wie???

MFG Christian18

[ichbins]

mit copyrect kannst du einzelne Bitmapteile ausschneiden.

Zitat:

ist das möglich???

Mit Delphi ist alles möglich. Frägt sich nur noch wie viele Millionen Assemblerzeilen man dazu braucht :zwinker:

[Christian18]

Zitat:

Zitat von ichbins

mit copyrect kannst du einzelne Bitmapteile ausschneiden.

und wie gehts dann weiter, wenn ich den ausschnitt in mein arbeitsspeicher kopiert habe?

[ichbins]

nein, das geht so:

Delphi-Quellcode:

var
  bmp,splitteer:tbitmap;
  r1,r2:trect;
begin
  //<-- ertmal bmp laden
  splitter:=tbitmap.create;
  splitter.width:=10;
  splitter.height:=10;
  splitter.copyrect(rect(0,0,10,10),bmp.canvas,rect(0,0,10,10));
end;

[SleepyMaster]

Hi Christian...

ich schreibe im Moment an einer Rotine zur Bilderkennung. Hier ist mal ein kleiner Schnipsel meines Programmes, mit dem ich ein Raster in ein Bild reinbekomme. Ist jetzt keine fertige Lösung, aber vlt hilfts dir ja weiter.

Delphi-Quellcode:

procedure TForm1.Button3Click(Sender: TObject);
const
  RSize = 10;
var
  x, y, i, j: integer;
  r, g, b: int64;
  Color: TColor;
begin
  y := 0;
  while y < (Image1.Picture.Bitmap.Height - RSize) do
    begin
    x := 0;
    while x < (Image1.Picture.Bitmap.Width - RSize) do
      begin
      r := 0;
      g := 0;
      b := 0;
      for i := 0 to RSize do
        for j := 0 to RSize do
          begin
          Color := Image1.Canvas.Pixels[x+i, y+j];

          r := r + GetRValue(Color);
          g := g + GetGValue(Color);
          b := b + GetBValue(Color);
          end;
      Color := RGB(Round(R / (RSize * RSize)), Round(G / (RSize * RSize)), Round(B / (RSize * RSize)));

      for i := 0 to RSize do
        for j := 0 to RSize do
          begin
          Image1.Canvas.Pixels[x+i, y+j] := Color;
          end;
      x := x + RSize;
      end;
    y := y + RSize;
    end;
end;

[Der_Unwissende]

Hi,
ja ein Raster kann das geben, du mittels doch hier Farbwerte, oder?

So oder so würde ich dir auch zu CopyRect oder Ähnliches raten. Wenn du auf einzelne Werte der Bitmap zugreifen möchtest, solltest du (hier auch ein Tipp an SleepyMaster) Pixels vermeiden, ist unheimlich langsam. Viel schneller kannst du das gleiche mit Scanline erreichen.
Das Einzigste was beim ScanLine Befehl beachtet werden sollte ist, dass man auf das Pixelformat achten muss. Wenn du nicht jeden Ausschnitt als eigenes Bitmap-Objekt brauchst, sondern nur die Farbwerte, dann solltest du einfach ein großes Array anlegen, die Daten (mittels Scanline) dort hinein kopieren und auf diese wie auf eine 10x10 Matrix zugreifen.

Gruß Der Unwissende

[SleepyMaster]

Ja, ich mittel die Farbwerte. Hier jetzt mal die optimierte Funktion von mir...

Delphi-Quellcode:

function DoResize(Bitmap: TBitmap; Width, Height: integer): TBitmap;
var
  SizeX, SizeY, X1, Y1, X2, Y2, I, J, PixelsInRect: integer;
  R, G, B: int64;
  Color: TColor;
  p1, p2 : pIntegerArray;
begin
  result := TBitmap.Create;

  result.PixelFormat := pf32Bit;
  Bitmap.PixelFormat := pf32Bit;

  SizeX := trunc(Bitmap.Width / Width);
  SizeY := trunc(Bitmap.Height / Height);

  result.Width := trunc(Bitmap.Width / SizeX);
  result.Height := trunc(Bitmap.Height / SizeY);

  PixelsInRect := (SizeX + 1) * (SizeY + 1);

  Y1 := 0;
  Y2 := 0;
  while Y1 <= (Bitmap.Height - SizeY) do
    begin
    p2 := result.ScanLine[Y2];
    x1 := 0;
    X2 := 0;
    while X1 <= (Bitmap.Width - SizeX) do
      begin
      r := 0;
      g := 0;
      b := 0;
      for i := 0 to SizeY do
        begin
        p1 := Bitmap.ScanLine[y1];
        for j := 0 to SizeX do
          begin
          b := b + (p1[x1] and $0000FF);
          g := g + ((p1[x1] and $00FF00) shr 8);
          r := r + ((p1[x1] and $FF0000) shr 16);
          end;
        end;
      p2[X2] := trunc(B / (PixelsInRect)) + (trunc(G / (PixelsInRect)) shl 8) + (trunc(R / (PixelsInRect)) shl 16);
      X1 := X1 + SizeX;
      X2 := X2 + 1;
      end;
    Y1 := Y1 + SizeY;
    Y2 := Y2 + 1;
    end;
end;

Edit1: Code nochmals optimiert ;)
Edit2: und nochmal :)
Edit3: Fehler ausgebessert :roteyes:

[Cicaro]

Zitat:

Zitat von ichbins

Mit Delphi ist alles möglich. Frägt sich nur noch wie viele Millionen Assemblerzeilen man dazu braucht :zwinker:

Ach ja ? Dann zeig' mir mal, wie man mit Delphi eine Variable aus einer DLL exportieren kann ohne sie mit dem Rückgabewert einer Funktion zurückzugeben.
In C++ ist das möglich. :zwinker:

Zum Thema:

Delphi-Quellcode:

// x und y geben die Position im Raster an und Width und Height die Rasterbreite und -höhe
BitBlt(ZielCanvas.Handle,0,0,Width,Height,QuellCanvas.Handle,x*Width,y*Height,SRCCOPY);

Damit zeichnet man das Rechteck das an der Position (0,0) liegt in ein anderes Canvas.

[Der_Unwissende]

Nun ja, was macht denn der Compiler aus C++-Code? Wenn es Assembler ist, hat ichbins dir die Antwort schon gegeben :wink:

[Cicaro]

Zitat:

Zitat von Der_Unwissende

Nun ja, was macht denn der Compiler aus C++-Code? Wenn es Assembler ist, hat ichbins dir die Antwort schon gegeben :wink:

Das Problem, das ich da angesprochen hab', hat nichts mit dem Inline-Assembler zu tun. Der Delphi-Compiler erlaubt das direkte Exportieren einer Variablen aus einer DLL nicht. Aber wenn mich jemand etwas anderes lehrt auch gut, dann weiß ich mehr. Übrigens ich verwende Delphi 7 Enterprise, nicht, dass das zu unnötigen Diskussionen führt.