World: r3wp

yes nice.

Looks cool, and seem to be good result with the rectangle packing. 
I would like to see a PNG version without the artifacts though. :-)

Remembers me on the old C64 days, where graphic chars were packed 
in a bitmap.

cool stuff Oldes!

Here is related script which I use to crop images according it's 
alpha channel:
>> do http://box.lebeda.ws/~hmm/rebol/get-img-alpha-bounds.r

>> get-img-alpha-bounds load http://box.lebeda.ws/~hmm/rebol/alpha-image.png
== [53 6 99 121]

Can anybody help me?
I have original image:

img1: make image! [5x1 #{AA0000AA0000AA0000AA0000AA0000} #{003F7FD8FF}]

which Flash IDE internaly stores as:

img2: make image! [5x1 #{A900007E0000540000190000000000} #{003E7ED8FF}]


I need to get the original from the flash version but have no info 
what flash does... any idea? I only know, that Flash is able to export 
the original from it's modified version.

the above can be also visualised as:
>> repeat i 5 [print [i img1/:i tab img2/:i]]
1 170.0.0.0      169.0.0.0
2 170.0.0.63     126.0.0.62
3 170.0.0.127    84.0.0.126
4 170.0.0.216    25.0.0.216
5 170.0.0.255    0.0.0.255

hm.. it's not exactly the same, but I can get the Flash version for 
red component as:

 repeat i 5 [c: img1/:i print to-integer   c/1 * (255 - c/4) / 255]

you could try looking visually at a few gradient tests just to understand 
what is happening, you might find a pattern.

That's what I was doing here:) Anyway.. the above is enough for me. 
It's not exactly same, but I cannot see difference when I see the 
image just by eye, because mainly almost invisible pixels are affected.

ah its premultiplying your pixels  !

it looks like premultiplication indeed.

ie, when you are compositing "img" over "bg", you basically do:  
bg * (1 - img_alpha) + img * img_alpha

they are precomputing img * img_alpha (a common tecnique) so that 
they can then simply do:  bg * (1 - img_alpha) + img

here is a simple function to swap channels from any image in R2

channel-copy: func [
	raster [image!]
	from [word!]
	to [word!]
	/into d
	/local pixel i b p 
][	
	b: to-binary raster
	
	d: to-binary any [d raster]
	
	from: switch from [
		red r [3]
		green g [2]
		blue b [1]
		alpha a [4]
	]

	to: switch to [
		red r [3]
		green g [2]
		blue b [1]
		alpha a [4]
	]

	either (xor from to) > 4 [

  ; when going to/from alpha we need to switch the value (rebol uses 
  transparency not opacity)
		repeat i to-integer (length? raster)  [
			p: i - 1 * 4
			poke d p + to to-char (255 - pick b p + from)
		]
	][
		repeat i to-integer (length? raster)  [
			p: i - 1 * 4
			poke d p + to to-char pick b p + from
		]
	]
	d: to-image d
	d/size: raster/size
	d
]

an example usage


circle: draw 100x100 [pen black fill-pen red circle 50x50 30]
circle/alpha: 0

alpha: draw 100x100 [pen white fill-pen white circle 50x50 30]
alpha/alpha: 0


line: draw 100x100 [
	pen blue
	fill-pen blue 
	line-width 5
	line 10x50 90x50
]

f: make face [
	offset: 100x100 
	color: gray
	pane: make face [
		color: none  
		image: line  
		text: "close for next"
		font: make font [color: white ]
	]
]

view f
f/pane/text: none

result: channel-copy/into line 'blue 'green circle
result: channel-copy/into alpha 'blue 'alpha result

f/pane/image: result



view f

note, images have to be same sizes if using /into refinement

also note that the function returns a new image (it doesn't modify 
"in-place")

btw, the swap code is not related to Olde's last question, even if 
it is loosely related... its a gift function for anyone who needs 
to copy channels (usually manipulating alphas)

Does anybody have done or begin a Box2d port in rebol ?

Is there something similar to this atan2 function in rebol (I guess 
no) :

http://msdn.microsoft.com/en-en/library/system.math.atan2%28v=vs.95%29.aspx

you have ARCTANGENT in rebol, atan2 should be easy to define based 
on it

I made ATAN2 while ago, I try to find it.

can't find it right now, but it was based on http://en.wikipedia.org/wiki/Atan2

Found 2 versions in my scripts.
atan2: func [

 {Angle of the vector (0,0)-(x,y) with artangent y / x. The resulting 
 angle is extended to -pi,+pi}
	x y
][
	if x = 0 [x: 0.0000000001]
	add arctangent y / x pick [0 180] x > 0
]

atan2: func [x y][
	x: x + 0.00000001
	either x > 0 [
		arctangent y / x
	][
		180 + arctangent y / x
	]
]

How many zeros after the decimal point?

does that matter ?

I mean, you can round the result

I don't know, that's why it seemed worth asking. Don't know the reason 
for that line. If it is supposed to be close to 0 then 15 or 16 zeros 
would be the closest.

Found another one:
atan2: func [x y][
	x: x + 0.00000001
	x: either x > 0 [arctangent y / x][180 + arctangent y / x]
	360 + x // 360
]
Geez... How many time I rewrote that one ? 
:-)

the last one is weird...

:-) Make function libs!

Hard to adapt the formulas in the Wikipedia article, as they're in 
radians.

>> ? arctangent 
USAGE:
    ARCTANGENT value /radians

Maybe use /radians refinement?

Maybe atan2 should also have a /radians refinement.

I like that one too.

Project: func [

 {orthogonal projection of a point P on a line AB, return coordinates 
 [x y]}
	ax ay bx by px py
	/local sx sy ux uy ratio
][
	sx: bx - ax
	sy: by - ay
	ux: px - ax
	uy: py - ay
	ratio:  sx * ux + (sy * uy) / (sx * sx + (sy * sy))
	reuse [ratio * sx + ax  ratio * sy + ay]
]

I don't remember why i didn't use pair! as coordinates

Hmm, maybe to avoid path notations

Pairs in R3 are 32bit floats, decimals are 64bit.

I was for R2

and pairs are integers

And in R2 pairs are made up of integers.

AltME is a little slow for me today.

Ok, I know why I did it now ;-)

reuse?

reuse: funco [b][head reduce/into b clear []]

weird, I don't think anymore it was for R2

Not task-safe to reuse inline blocks like that.

And I don't like anymore that reuse too :-)

We should write an extension with such math/graphs functions

Maybe Brian you could start a wiki page for that purpose