Glow, Blur in 2d with no opengl or d3d ? possible ? [Archive]

arthurprs

06-07-2007, 04:17 PM

The titles explains itself :?

sorry my bad english

JernejL

06-07-2007, 04:24 PM

i have some code to blur a image somewhere if you need that.

WILL

06-07-2007, 04:24 PM

Not really. :roll: What platform, compiler, language are you using?

Anything is possible, only the exact implementation can be impossible.

btw, Welcome to PGD. :)

arthurprs

06-07-2007, 05:11 PM

Not really. :roll: What platform, compiler, language are you using?

Anything is possible, only the exact implementation can be impossible.

btw, Welcome to PGD. :)

Opz sorry :?

Windows,
Delphi 2006 win32,
Object pascal...

arthurprs

06-07-2007, 05:11 PM

i have some code to blur a image somewhere if you need that.

Ohh it will be great ^^

JernejL

06-07-2007, 05:43 PM

{

Gaussian Blur in Delphi

From: ullrich@math.okstate.edu
You can do it like so. In informal testing it appears to take roughly twice as much time as Adobe Photoshop takes to do the same thing, which seems pretty OK to me - there are a lot of things you could do to speed it up.
The gaussian kernel exp(-(x^2 + y^2)) is of the form f(x)*g(y), which means that you can perform a two-dimensional convolution by doing a sequence of one-dimensional convolutions - first you convolve each row and then each column. This is much faster (an N^2 becomes an N*2). Any convolution requires some temporary storage - below the BlurRow routine allocates and frees the memory, meaning that it gets allocated and freed once for each row. Probably changing this would speed it up some, it's not entirely clear how much.
The kernel "size" is limited to 200 entries. In fact if you use radius anything like that large it will take forever - you want to try this with a radius = 3 or 5 or something. For a kernel with that many entries a straight convolution is the thing to do, while when the kernel gets much larger Fourier transform techniques will be better (I couldn't say what the actual cutoff is.)
One comment that needs to be made is that a gaussian blur has the magical property that you can blur each row one by one and then blur each column - this is much faster than an actual 2-d convolution.
Anyway, you can do this:
}

unit GBlur2;

interface

uses Windows, Graphics;

type
PRGBTriple = ^TRGBTriple;
TRGBTriple = packed record
b: byte; //easier to type than rgbtBlue...
g: byte;
r: byte;
end;

PRow = ^TRow;
TRow = array[0..1000000] of TRGBTriple;

PPRows = ^TPRows;
TPRows = array[0..1000000] of PRow;

const MaxKernelSize = 100;

type

TKernelSize = 1..MaxKernelSize;

TKernel = record
Size: TKernelSize;
Weights: array[-MaxKernelSize..MaxKernelSize] of single;
end;
//the idea is that when using a TKernel you ignore the Weights
//except for Weights in the range -Size..Size.

procedure GBlur(theBitmap: TBitmap; radius: single);

implementation

uses SysUtils;

procedure MakeGaussianKernel(var K: TKernel; radius: single;
MaxData, DataGranularity: single);
//makes K into a gaussian kernel with standard deviation = radius.
//for the current application you set MaxData = 255,
//DataGranularity = 1. Now the procedure sets the value of
//K.Size so that when we use K we will ignore the Weights
//that are so small they can't possibly matter. (Small Size
//is good because the execution time is going to be
//propertional to K.Size.)
var j: integer; temp, delta: single; KernelSize: TKernelSize;
begin
for j:= Low(K.Weights) to High(K.Weights) do
begin
temp:= j/radius;
K.Weights[j]:= exp(- temp*temp/2);
end;

//now divide by constant so sum(Weights) = 1:

temp:= 0;
for j:= Low(K.Weights) to High(K.Weights) do
temp:= temp + K.Weights[j];
for j:= Low(K.Weights) to High(K.Weights) do
K.Weights[j]:= K.Weights[j] / temp;

//now discard (or rather mark as ignorable by setting Size)
//the entries that are too small to matter -
//this is important, otherwise a blur with a small radius
//will take as long as with a large radius...
KernelSize:= MaxKernelSize;
delta:= DataGranularity / (2*MaxData);
temp:= 0;
while (temp <delta> 1) do
begin
temp:= temp + 2 * K.Weights[KernelSize];
dec(KernelSize);
end;

K.Size:= KernelSize;

//now just to be correct go back and jiggle again so the
//sum of the entries we'll be using is exactly 1:

temp:= 0;
for j:= -K.Size to K.Size do
temp:= temp + K.Weights[j];
for j:= -K.Size to K.Size do
K.Weights[j]:= K.Weights[j] / temp;

end;

function TrimInt(Lower, Upper, theInteger: integer): integer;
begin
if (theInteger <Upper>= Lower) then
result:= theInteger
else
if theInteger > Upper then
result:= Upper
else
result:= Lower;
end;

function TrimReal(Lower, Upper: integer; x: single): integer;
begin
if (x <upper>= lower) then
result:= trunc(x)
else
if x > Upper then
result:= Upper
else
result:= Lower;
end;

procedure BlurRow(var theRow: array of TRGBTriple; K: TKernel; P: PRow);
var j, n, LocalRow: integer; tr, tg, tb: single; //tempRed, etc
w: single;
begin

for j:= 0 to High(theRow) do
begin
tb:= 0;
tg:= 0;
tr:= 0;
for n:= -K.Size to K.Size do
begin
w:= K.Weights[n];

//the TrimInt keeps us from running off the edge of the row...
with theRow[TrimInt(0, High(theRow), j - n)] do
begin
tb:= tb + w * b;
tg:= tg + w * g;
tr:= tr + w * r;
end;
end;
with P[j] do
begin
b:= TrimReal(0, 255, tb);
g:= TrimReal(0, 255, tg);
r:= TrimReal(0, 255, tr);
end;
end;

Move(P[0], theRow[0], (High(theRow) + 1) * Sizeof(TRGBTriple));
end;

procedure GBlur(theBitmap: TBitmap; radius: single);
var Row, Col: integer; theRows: PPRows; K: TKernel; ACol: PRow; P:PRow;
begin
if (theBitmap.HandleType <> bmDIB) or (theBitmap.PixelFormat <> pf24Bit) then
raise exception.Create('GBlur only works for 24-bit bitmaps');

MakeGaussianKernel(K, radius, 255, 1);
GetMem(theRows, theBitmap.Height * SizeOf(PRow));
GetMem(ACol, theBitmap.Height * SizeOf(TRGBTriple));

//record the location of the bitmap data:
for Row:= 0 to theBitmap.Height - 1 do
theRows[Row]:= theBitmap.Scanline[Row];

//blur each row:
P:= AllocMem(theBitmap.Width*SizeOf(TRGBTriple));
for Row:= 0 to theBitmap.Height - 1 do
BlurRow(Slice(theRows[Row]^, theBitmap.Width), K, P);

//now blur each column
ReAllocMem(P, theBitmap.Height*SizeOf(TRGBTriple));
for Col:= 0 to theBitmap.Width - 1 do
begin
//- first read the column into a TRow:
for Row:= 0 to theBitmap.Height - 1 do
ACol[Row]:= theRows[Row][Col];

BlurRow(Slice(ACol^, theBitmap.Height), K, P);

//now put that row, um, column back into the data:
for Row:= 0 to theBitmap.Height - 1 do
theRows[Row][Col]:= ACol[Row];
end;

FreeMem(theRows);
FreeMem(ACol);
ReAllocMem(P, 0);
end;

end.

arthurprs

09-07-2007, 04:00 AM

{

Ohh thx =)

anything about glow ?

JernejL

09-07-2007, 07:38 AM

glow is a variant of blur.. but i have nothing to work with that.

jasonf

09-07-2007, 09:57 AM

If you look in the Jedi-SDL library, there's a Kernel effect system which I ported from some C code a long time ago, it's still there though.

I think that what you need for Glow is Gradual Outlines at progressively darker colours.

Basically, you create a surface to contain your glow,
fill it with black
and you draw an outline of your sprite on it. So your new surface contains a nice outline of your sprite.

Then using a slightly darker colour, on the same surface, you draw an outline around your previous outline..

(You'll have to check for the colour of the previous outline or you'll end up bleeding colour where you don't want it)

Continue doing this until you're using a dark enough colour.

then, Additive Blit your new glow to the screen.

The technique is quite processor intensive, so you'll probably want to cache your results.

arthurprs

09-07-2007, 05:01 PM

If you look in the Jedi-SDL library, there's a Kernel effect system which I ported from some C code a long time ago, it's still there though.

I think that what you need for Glow is Gradual Outlines at progressively darker colours.

Basically, you create a surface to contain your glow,
fill it with black
and you draw an outline of your sprite on it. So your new surface contains a nice outline of your sprite.

Then using a slightly darker colour, on the same surface, you draw an outline around your previous outline..

(You'll have to check for the colour of the previous outline or you'll end up bleeding colour where you don't want it)

Continue doing this until you're using a dark enough colour.

then, Additive Blit your new glow to the screen.

The technique is quite processor intensive, so you'll probably want to cache your results.

Any ready code ?

jasonf

10-07-2007, 02:33 PM

Ready code?... Nope. But the code is very simple.

procedure outline( destinationpixels, sourcepixels, transparent, outlinecolour)

For x = 0 to sourcewidth

For y = 0 to sourceheight

if sourcepixels( x,y ) = transparent and
( sourcepixels( x-1, y ) <> transparent or
sourcepixels( x+1, y ) <> transparent or
sourcepixels( x, y-1 ) <> transparent or
sourcepixels( x, y+1 ) <> transparent ) then
destinationpixels( x,y ) = outlinecolour
end if

next y

next x

end procedure

procedure makeglow( destinationpixels, sourcepixels, transparentcolour, outlinecolour , outlinedarknessfactor, outlinesteps )

outline( destinationpixels, sourcepixels, transparent,outlinecolour )

for i = 1 to outlinesteps

tempsource = copydestinationtotempdestination( destinationpixels )

outlinecolour = outlinecolour - outlinedarknessfactor

outline( destinationpixels, tempsource, transparent, outlinecolour )

next i

end procedure

sorry, I can't write it in pascal at the moment, I don't have access to a pascal IDE.. so I've done it in Pseudocode.

arthurprs

10-07-2007, 04:03 PM

Ready code?... Nope. But the code is very simple.

procedure outline( destinationpixels, sourcepixels, transparent, outlinecolour)

For x = 0 to sourcewidth

For y = 0 to sourceheight

if sourcepixels( x,y ) = transparent and
( sourcepixels( x-1, y ) <> transparent or
sourcepixels( x+1, y ) <> transparent or
sourcepixels( x, y-1 ) <> transparent or
sourcepixels( x, y+1 ) <> transparent ) then
destinationpixels( x,y ) = outlinecolour
end if

next y

next x

end procedure

procedure makeglow( destinationpixels, sourcepixels, transparentcolour, outlinecolour , outlinedarknessfactor, outlinesteps )

outline( destinationpixels, sourcepixels, transparent,outlinecolour )

for i = 1 to outlinesteps

tempsource = copydestinationtotempdestination( destinationpixels )

outlinecolour = outlinecolour - outlinedarknessfactor

outline( destinationpixels, tempsource, transparent, outlinecolour )

next i

end procedure

sorry, I can't write it in pascal at the moment, I don't have access to a pascal IDE.. so I've done it in Pseudocode.

It looks like a MIX of Basic and Pascal

jasonf

11-07-2007, 08:13 AM

well, yeah, it's a kind-of mix of both.. needless to say, it won't compile.

Can you see what I'm trying to show you though?

You see, writing a glow function is pretty much library dependent so I can't just write the code. You'll need access to the surface memory so you can manipulate it. Different libraries expose the underlying surface in different ways, some give an array of pixels you can use.

If you're using the Jedi-SDL library then you're going to have a different mechanism to access the surface memory than with DelphiX.

Once you've written a function which works for your library, you'll only want to call it whenever your main image (the one which you're generating the glow for) changes.. otherwise, you'll eat processor cycles re-generating the same glow for every frame.

arthurprs

11-07-2007, 10:20 PM

well, yeah, it's a kind-of mix of both.. needless to say, it won't compile.

Can you see what I'm trying to show you though?

You see, writing a glow function is pretty much library dependent so I can't just write the code. You'll need access to the surface memory so you can manipulate it. Different libraries expose the underlying surface in different ways, some give an array of pixels you can use.

If you're using the Jedi-SDL library then you're going to have a different mechanism to access the surface memory than with DelphiX.

Once you've written a function which works for your library, you'll only want to call it whenever your main image (the one which you're generating the glow for) changes.. otherwise, you'll eat processor cycles re-generating the same glow for every frame.

I will try the code =)

I will post results later.

arthurprs

14-07-2007, 03:01 PM

function Tform1.outline( src : TBitmap ; transparentcolor , outlinecolor : TColor ): Tbitmap;
var
x, y: Integer;
begin

result:= TBitmap.Create;
zprofiler.Mark(1,True);
Result.Assign(src);
zprofiler.Mark(1,False);

for x := 1 to src.Width - 2 do
for y := 1 to src.Height - 2 do
begin
if (src.Canvas.Pixels[ x,y ] = transparentcolor) and
( (src.Canvas.Pixels[ x-1, y ] <> transparentcolor) or
(src.Canvas.Pixels[ x+1, y ] <> transparentcolor) or
(src.Canvas.Pixels[ x, y-1 ] <> transparentcolor) or
(src.Canvas.Pixels[ x, y+1 ] <> transparentcolor) ) then
Result.Canvas.Pixels[ x,y ] := outlinecolor;
end;
end;

function Tform1.makeglow(src : Tbitmap ; transparentcolor , glowcolor : TColor; outlinedarknessfactor, outlinesteps: Integer): TBitmap;
var
count : Integer;
begin
Result := TBitmap.Create;
Result.Assign(src);
for count:= 0 to outlinesteps-1 do
begin
Result := outline( Result, transparentcolor, glowcolor);
glowcolor := glowcolor + outlinedarknessfactor; // << this is wrong i know
end;
end;

procedure TForm1.Image1Click(Sender: TObject);
begin
image2.Picture.Bitmap:= makeglow(Image1.Picture.Bitmap, RGB(255,0,255), RGB(0,100,250), 100, 3);
end;

;] it appers to have worked

http://upload9.postimage.org/277064/Untitled_2.jpg (http://upload9.postimage.org/277064/photo_hosting.html)

But the code is toooooo slow :(
i think im making something wrong

EDIT: Reuploaded the img cuz jpeg is a TRASH to show details

JernejL

14-07-2007, 06:29 PM

Ofcourse it is slow on cpu! that's why people do such effects with graphic cards!

arthurprs

14-07-2007, 08:04 PM

Ofcourse it is slow on cpu! that's why people do such effects with graphic cards!

How can i make gpu do the work ?

JernejL

14-07-2007, 08:23 PM

by using opengl or d3d to do the fancy rendering.

wagenheimer

16-07-2007, 01:35 AM

There are some example of how to do this on Asphyre without using shaders?

Robert Kosek

16-07-2007, 02:12 AM

The general idea given, in the example of blurred vector/line games, was that you render to a small rendertarget, render normally, and then stretch the rendertarget over the screen with anti-aliasing on. Of course you must give it a transparency value and correct blendmode. It gives a pretty good result from what I understand.

Without shaders that is pretty much the best you can do. At least efficiently.

Andreaz

16-07-2007, 05:07 AM

Use Bitmap.Scanline instead of Bitmap.Canvas.Pixels[ x,y ] and you'll jump alot in speed;

The following code is to convert a Phoenix texture to a windows Bitmap showing the use of scanline:

Type TRGBQuadArray = Array[WORD] of TRGBQuad;
Type PRGBQuadArray = ^TRGBQuadArray;
Type TRGBTripleArray = Array[WORD] of TRGBTriple;
Type PRGBTripleArray = ^TRGBTripleArray;

var Line : PRGBTripleArray;
var X,Y : Integer;
var Color : TColor4b;
begin
Dest.Width := Source.Width;
Dest.Height := Source.Height;
Dest.PixelFormat:= Graphics.pf24Bit;

For Y:=0 to Source.Height-1 do begin
Line:=Dest.ScanLine[Y];
For X:=0 to Source.Width-1 do begin
Color:= Source.Pixels[X,Y];

Line[X].rgbtRed := Color.Red ;
Line[X].rgbtGreen := Color.Green;
Line[X].rgbtBlue := Color.Blue ;
end;
end;

arthurprs

16-07-2007, 06:43 AM

Use Bitmap.Scanline instead of Bitmap.Canvas.Pixels[ x,y ] and you'll jump alot in speed;

The following code is to convert a Phoenix texture to a windows Bitmap showing the use of scanline:

Type TRGBQuadArray = Array[WORD] of TRGBQuad;
Type PRGBQuadArray = ^TRGBQuadArray;
Type TRGBTripleArray = Array[WORD] of TRGBTriple;
Type PRGBTripleArray = ^TRGBTripleArray;

var Line : PRGBTripleArray;
var X,Y : Integer;
var Color : TColor4b;
begin
Dest.Width := Source.Width;
Dest.Height := Source.Height;
Dest.PixelFormat:= Graphics.pf24Bit;

For Y:=0 to Source.Height-1 do begin
Line:=Dest.ScanLine[Y];
For X:=0 to Source.Width-1 do begin
Color:= Source.Pixels[X,Y];

Line[X].rgbtRed := Color.Red ;
Line[X].rgbtGreen := Color.Green;
Line[X].rgbtBlue := Color.Blue ;
end;
end;

I will try =]

jasonf

16-07-2007, 10:05 AM

Also, Cache your results wherever possible, don't regenerate glows for images you've already generated glows for.

To speed the process up, if you have a small number of sprites, you could generate glows for all of your sprites before the game begins.. or generate and cache them as you go if you have more.

By doing this, you, and not making your glows for every render, you'll improve your performance enormously.

How you implement your cache system is up to you though, I could suggest something, but it might be incompatible with your game engine.

arthurprs

16-07-2007, 10:23 PM

Also, Cache your results wherever possible, don't regenerate glows for images you've already generated glows for.

To speed the process up, if you have a small number of sprites, you could generate glows for all of your sprites before the game begins.. or generate and cache them as you go if you have more.

By doing this, you, and not making your glows for every render, you'll improve your performance enormously.

How you implement your cache system is up to you though, I could suggest something, but it might be incompatible with your game engine.

Suggest :P

jasonf

17-07-2007, 07:56 PM

Well, one way would be to use a list of some type, something which gives you access to objects contained within using a key. I use a TStringList

Then, all you need to do is.

1. Drawing routine wants to draw a glow for sprite named "MAN"

2. Check GlowCache (aformentioned list), If glowsurface exists, return it.

2.1 If glow surface does not exist, render the glow to a new surface for the sprite named "MAN" and add the glow to the cache with the key of "MAN", return it.

3. Render the glow to the destination surface.

From this point on, all calls for a glow for the sprite "MAN" will return a pre-generated glow.