World: r3wp

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

Maybe it would be better for someone more familiar with and interested 
in mathematical issues to do so. Ladislav?

advise on how to colorize individual countries in a worldmap?
take a worldmap, draw background borders between the countries
and then floodfill the country via a central coordinate. 
is this a effective approach?

Not enough probably as you might jave country border touching other 
border of the same countryy. Countries are not simple polygon !

My first though is to have a map (an image) of countries where each 
country has its own color (call it a color-map) and another map of 
the same size that you display (diplay-map).
Then you have a block of pairs [country-name country-color].
So like this you have a relationship in any sense.


Click the displayed map => find the corresponding pixel in the color-map 
=> find the country name in the block.

To know the edge of the country you want to fill, just find all the 
pixels of this same color in the color-map and poke the corresponding 
pixel on the diplay-map.

jave=have