probleme mit theorie der grafikskalierung

loki1985

hi folks!

bin gerade dabei, eine funktion zur schnellen grafikskalierung zu planen.

also ein einfacher pixel-array soll frei größer oder kleiner gemacht werden.
also nicht nur um gerade faktoren, sondern bei bedarf auch z.b. mal 1.14.

das problem: pixel-wiederholung wäre am einfachsten, sieht aber richtig sch**** aus. auf hardware-ebene will ich das nicht machen, da das komplette drumrum im softwaremode arbeitet (und nur wegen einer kleinen sache auf hardware umzustrukturieren fände ich plöt).

nächstes problem: das skalierte objekt soll vor einem hintergrund dargestellt werden. das bringt wieder ein neues problem mit sich, da das objekt in den meisten fällen teilweise durchsichtig ist (momentan noch ohne antialiasing jeder art, also nur nicht durchsichtige oder voll durchsichtige pixel).

welche ideen und tips könnt ihr mir sagen?

danke,

---loki

TGGC

Du könntest einfach eine (bi)lineare Interpolation drüberjagen. Beim Verkleinern könntest du allerdings ein paar Probleme mit Flimmern bekommen.

Bye, TGGC

loki1985

hmm, wenn ich das richtig verstehe heisst linear interpolieren dass ich ein pixel z.b. mit dem daneben "verschmelze", also nen mittelwert errechne. right?
was ist dann bi-linear? rechtes UND linkes pixel, oder gleich ein 2x2-feld?

bemerke grad: wobei das ja nur verkleinern wäre. beim vergrößern wirds dann wohl einfach nur einen mittelwert dazu geben.

wird auf jeden fall ne schnelle methode sein

das einzige was ich dann nicht ganz kapiere? wie entscheide ich, welche pixel verschmolzen werden sollen? also irgendwie muss es ja jedes X-te pixel sein, X abhängig vom resize-faktor..... naja, muss die idee noch etwas weiterwälzen.

aber schon mal vielen dank... ich glaube ich schreib mal einen kleinen test in SDL....

rapso

bilinear funzt beim vergrößern besser als beim verkleinern.

du gehst das neue bild pixel für pixel durch, dabei errechnest du die pixelcoordinaten für das ursprungsbild indem du die aktuellen coordinaten durch deinen skalierungsfaktor teilst

z.b.

int OldX = NewX/Faktor;
int OldY = NewX/Faktor;

die 4 pixel ließt du mit

int P00=Pixel(OldX,OldY);
int P10=Pixel(OldX+1,OldY);
int P01=Pixel(OldX,OldY+1);
int P11=Pixel(OldX+1,OldY+1);

das interpolieren machst du mit den nachkommastellen die beim umskalieren von den neuen zu den alten koordinaten entstehen.

float lerpX = NewX/Faktor-OldX;
float lerpY = NewX/Faktor-OldY;

danach interpolierst du damit zwischen den beiden pixelpaaren auf der Y-ebene mittels LerpX und zwischen den zwei resultaten dann mittels lerpY.

so in etwa müßte es sein

rapso->greets();