Bilder drucken mit GR32lib

[alienous]

hi,

hab ein kleines problem, beim druck im LOMETRIC modus (wahrscheinlich bei allen modi) erscheint mir das gedruckte bild verfälscht! dabei öffne ich das bild mit der Image32 kompo, und übergebe das handle dem drucker, also ich verändere am bild nichts, und trotzdem erscheint es mir "heller" und evntl mit einem rotstich im vergleich zum ausdruck des selben bildes mit photoshop etc.

woran kann das liegen? habt ihr ähnliche erfahrungen gemacht? wieso sehen die bilder, die mit anderen komerziellen programmen gedruckt werden, viel besser aus? behandeln die die bilder noch mit irgendwelchen routinen oder hat es was mit den farbschemen zutun?

komme da echt nich weiter, need help! :)

danke

[SirThornberry]

wie übergibst du denn dem Drucker das Handle?

[alienous]

ach sorry, hab mich da wohl verschrieben, das is meine methode

Delphi-Quellcode:

procedure BildDrucken(PCanvas : TCanvas; px1, py1, px2, py2 : Integer; pmotiv : tmotiv);
var gra : Tbitmap32;
begin
        gra := Tbitmap32.Create;
        gra.LoadFromFile('C:\motive\'+pmotiv.Bildname);
        gra.Rotate270();
        gra.DrawTo(pcanvas.Handle, Rect(px1,py1,px2,py2), gra.BoundsRect);
        gra.Free;
end;

und der aufruf:

Delphi-Quellcode:

  with Printer do
  begin
    BeginDoc;
    SetMapMode(Canvas.Handle, MM_LOMETRIC);
    BildDrucken(Canvas, 0, 0, motivbreite, motivhoehe, TestMotiv); 
    EndDoc;
  end;

so, hoffentlich isses zu verstehen :)

[SirThornberry]

Hast du es schonmal mit einem normalen TBitmap versucht? Im übrigen scheint es als würde dein Bild durch dein Drehen gespiegelt ausgegeben werden denn durch dein drehen wird links und rechts auch mit vertauscht.

[alienous]

meinste das liegt am spiegeln? weiss gerade nicht wo du das siehst, wie würdest du es machen?

und da das programm später dazu genutzt wird, um fotos zu drucken, kann ich nicht die normalen imagekomponenten nutzen, da die allein schon von der qualität schlechter sind. eventuell sollen noch so gimmiks wie bildrand rein, dazu braucht man ja transparenz. hab mich vorher informiert hier im board durch suchen, und denke, das für mich somit ja nur gr32 in frage kommt. aber so wie es aussieht, nutzen die kompo doch ziehmlich viele, ist es denen etwa nich aufgefallen? schon seltsam die problematik.

[alienous]

habe jetz noch etwas mit

Delphi-Quellcode:

gra.ResamplerClassName := 'TLinearResampler';

experimentiert, und dabei die ausgabe in ein TImage32 auf der form geleitet, dabei werden die farben ziehmlich stark verfälscht, mit und ohne den resampler! wieso? liegt es eventuell am drawto?
wenn ich das bild direkt mit der kompo öffne, wird das bild korrekt angezeigt. :wall:

Delphi-Quellcode:

procedure BildDrucken(PCanvas : TCanvas; px1, py1, px2, py2 : Integer; pmotiv : tmotiv);
var gra : Tbitmap32;
begin
        gra := Tbitmap32.Create;
        gra.LoadFromFile('C:\motive\'+pmotiv.Bildname);
        gra.ResamplerClassName := 'TLinearResampler';
        //gra.Rotate270();
        gra.DrawTo(pcanvas.Handle, Rect(px1,py1,px2,py2), gra.BoundsRect);
        gra.Free;
end;

[DGL-luke]

Ich würd n TKernelResampler mit Lanczos hernehmen.

also Classname auf TKernelResampler und irgendwo kannst du dann diesen Kernel einstellen... "ResamplerKernel" oder "Kernelmode" im TBitmap32 muss das sein...

[alienous]

soo, habs jetz so ungefähr, liegt der fehler aber wirklich am fehlenden resampler? schaut euch mal das bild im anhang aus, wie das kindergesicht angezeigt wird nach dem code hier:

Delphi-Quellcode:

procedure BildDrucken(PCanvas : TCanvas; px1, py1, px2, py2 : Integer; pmotiv : tmotiv);
var gra,gra2 : Tbitmap32;
    KRS: TKernelResampler;
begin
        gra := Tbitmap32.Create;
        gra2 := Tbitmap32.Create;
        gra.LoadFromFile('C:\motive\'+pmotiv.Bildname);

        //KRS := TKernelResampler.Create(gra);
        //KRS.Kernel := TLanczosKernel.Create;
      
        gra.DrawTo(pcanvas.Handle, Rect(px1,py1,px2,py2), gra.BoundsRect);
        gra.Free;
        gra2.Free;
end;

kann es auch sein, das tbitmap32 das bild beim drawto oder beim rotieren eventuell etwas aufhellt?

danke

[DGL-luke]

also sowas sollte eigentlich nicht passieren... und aufgehellt wird normalerweise auch nichts... ich bin mit meinem latein am ende. das sieht ja schon nach veritablen falschfarben aus...

[SirThornberry]

was spricht dagegen das bild mit bitblt oder stretchblt auf die Druckercanvas zu bringen?

[DGL-luke]

Die Qualität?

[SirThornberry]

wenns um die Qualität geht würde ich vorher das Bild resamplen und dann mit BitBlt auf die Canvas bringen. Desweiteren war ich bisher eigentlich immer mit der Qualtitäg von StretchBlt mit Halftone-Mode zufrieden.

[alienous]

ach leute, ich weiss jetz, wieso die bilder so verunstaltet wurden, ich hab an drawTo das canvas.handle übergeben, anstatt die Bitmap, mit bitmap erhalte ich ein schönes bild! kann die schlechtere druckqualität vielleicht damit zusammenhängen das ich dort das printer-canvas.handle übergebe? wie könnte ich das umgehen? ich glaub wir nähern uns dem ziehl! bitte nicht aufgeben luke :D

[DGL-luke]

@SirT: allerdings, da hast du recht.
der resampler ist (ich gehe da von der vorherigen version mit stretchfilter aus) auch nur zum zeichnen AUF ein TBitmap32 geeignet.

@alienous: Du solltest das Bild also erst skalieren und dann auf den printer zeichnen.

[alienous]

also meinste das so in etwa:

SrcBild -> Bitmap32_1 -> resampledResizen-> Bitmap32_2 -> Bitmap32_2.canvas übergeben an printer.canvas

so in etwa? wobei Bitmap32_2 von den ausmaßen genau dem printer entspricht?

setze mich sofort drann, aber das resizen mit dem resampler macht mir probleme, evntl bräuchte ich da noch was hilfe.

[DGL-luke]

Also ich hab da schon öfter selber was geschrieben...

Delphi-Quellcode:

function ResizePropertional(Src: TBitmap32; AvailDim: TPoint): TBitmap32;
var factor: real; //Skalierungsfaktor
    NewDim: TPoint; //Neue Ausmaße
begin
  factor := Min(Src.Width / AvailDim.X, Src.Height / AvailDim.Y); // Skalierungsfaktor ermitteln
  NewDim.X := Floor(Src.Width * factor);  //Neue Breite errechnen
  NewDim.Y := Floor(Src.Height * factor); // "   Höhe   "

  Result := TBitmap32.Create;
  Result.Width := NewDim.X;
  Result.height := NewDim.Y;

  Result.Resampler := TKernelResampler.Create(Result);

  with Result.Resampler as TKernelResampler do   //Kernelmode (=tatsächlicher Filter) zuweisen
    if (factor > 1) then//Vergrößerung
      KernelMode := kmMitchell
    else //Verkleinerung
      KernelMode := kmLanczos;

  Result.Draw(Src.Width,Src.Height,Result,Result.Width,Result.Height);
end;

So in etwa müsste es gehen, aus dem Stegreif getippt.
Bin mir bei der Zuweisung der Resampler und beim zeichnen aber überhaupt nicht sichwer, ob das so kompiliert geschweige denn funktioniert.
Sollte es das tun, wäre es mir natürlich eine Ehre, den Code für die CodeLib vorzuschlagen ;)

[alienous]

hm ok da fällt mir auf, das ich wieder bitmap32 zurückbekomme, wie kannich das dann auf das printer.canvas malen ohne verluste?

[SirThornberry]

wenn du auf das die Canvas ein Handle hast mit BitBlt

[alienous]

alles klar, scheint zu klappen, morgen werd ich mir die qualitätsunterschiede anschauen, hoffentlich war es das :hi:

@luke: wenns das war, schau ich mir deinen code an :wink: