jaime.oliver2

Is there a way of seeing the cource code for jit.brcosa?? or at least

know what the algorithm is? specially for brightness...

Is there a way of seeing the cource code for jit.brcosa?? or at least
know what the algorithm is? specially for brightness...

joliverl@ucsd.edu
www.realidadvisual.org/jaimeoliver
www-crca.ucsd.edu/
www.realidadvisual.org

9168 Regents Rd. Apt. G
La Jolla, CA 92037
USA


jit-brcosa-source

check out the co.brcosa.jxs shader for ideas about how this might work.

> Is there a way of seeing the cource code for jit.brcosa?? or at least

> know what the algorithm is? specially for brightness...

On 11/5/07, Jaime Oliver  wrote:
> Hello,
>
> Is there a way of seeing the cource code for jit.brcosa?? or at least
> know what the algorithm is? specially for brightness...
>
> any pointers are welcome,
>
> J
>
> --
> Jaime E Oliver LR
>
> joliverl@ucsd.edu
> www.realidadvisual.org/jaimeoliver
> www-crca.ucsd.edu/
> www.realidadvisual.org
>
> 9168 Regents Rd. Apt. G
> La Jolla, CA 92037
> USA
>


I found references to cc.brcosa.jxs shader, but can't find any code

associated to it. do you have a link to it?

> check out the co.brcosa.jxs shader for ideas about how this might work.

> > Is there a way of seeing the cource code for jit.brcosa?? or at least

> > know what the algorithm is? specially for brightness...

I found references to cc.brcosa.jxs shader, but can't find any code
associated to it. do you have a link to it?

On 11/5/07, Wesley Smith  wrote:
> check out the co.brcosa.jxs shader for ideas about how this might work.
>
> wes
>
> On 11/5/07, Jaime Oliver  wrote:
> > Hello,
> >
> > Is there a way of seeing the cource code for jit.brcosa?? or at least
> > know what the algorithm is? specially for brightness...
> >
> > any pointers are welcome,
> >
> > J
> >
> > --
> > Jaime E Oliver LR
> >
> > joliverl@ucsd.edu
> > www.realidadvisual.org/jaimeoliver
> > www-crca.ucsd.edu/
> > www.realidadvisual.org
> >
> > 9168 Regents Rd. Apt. G
> > La Jolla, CA 92037
> > USA
> >
>

basically, you just need to look at the fragment and can deduct what

const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721);

    vec3 texColor     = texture2DRect(image, texcoord).rgb;

    vec3 intensity     = vec3 (dot(texColor, LumCoeff));

    vec3 color     = mix(intensity, texColor, saturation);

    color     = mix(avgluma, color, contrast);

    color            *= brightness;

    gl_FragColor     = vec4 (color, color.g*alpha);

> I found references to cc.brcosa.jxs shader, but can't find any code

> associated to it. do you have a link to it?

> > check out the co.brcosa.jxs shader for ideas about how this might work.

> > > Is there a way of seeing the cource code for jit.brcosa?? or at least

> > > know what the algorithm is? specially for brightness...

basically, you just need to look at the fragment and can deduct what
it would look like tin CPU source code:

varying vec2 texcoord;
uniform sampler2DRect image;

uniform vec3 avgluma;
uniform float saturation;
uniform float contrast;
uniform float brightness;
uniform float alpha;

void main (void)
{
	vec3 texColor  	= texture2DRect(image, texcoord).rgb;
	vec3 intensity 	= vec3 (dot(texColor, LumCoeff));
	vec3 color     	= mix(intensity, texColor, saturation);
	color          	= mix(avgluma, color, contrast);
	color			*= brightness;
	gl_FragColor   	= vec4 (color, color.g*alpha);
}

On 11/5/07, Jaime Oliver  wrote:
> Hi Wesley,
>
> thanks for your answer,
>
> I found references to cc.brcosa.jxs shader, but can't find any code
> associated to it. do you have a link to it?
>
> best,
>
> Jaime
>
> On 11/5/07, Wesley Smith  wrote:
> > check out the co.brcosa.jxs shader for ideas about how this might work.
> >
> > wes
> >
> > On 11/5/07, Jaime Oliver  wrote:
> > > Hello,
> > >
> > > Is there a way of seeing the cource code for jit.brcosa?? or at least
> > > know what the algorithm is? specially for brightness...
> > >
> > > any pointers are welcome,
> > >
> > > J
> > >
> > > --
> > > Jaime E Oliver LR
> > >
> > > joliverl@ucsd.edu
> > > www.realidadvisual.org/jaimeoliver
> > > www-crca.ucsd.edu/
> > > www.realidadvisual.org
> > >
> > > 9168 Regents Rd. Apt. G
> > > La Jolla, CA 92037
> > > USA
> > >
> >
>
>
> --
> Jaime E Oliver LR
>
> joliverl@ucsd.edu
> www.realidadvisual.org/jaimeoliver
> www-crca.ucsd.edu/
> www.realidadvisual.org
>
> 9168 Regents Rd. Apt. G
> La Jolla, CA 92037
> USA
>


> basically, you just need to look at the fragment and can deduct what

> it would look like tin CPU source code:

> const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721);

> vec3 texColor = texture2DRect(image, texcoord).rgb;

> vec3 intensity = vec3 (dot(texColor, LumCoeff));

> vec3 color = mix(intensity, texColor, saturation);

> gl_FragColor = vec4 (color, color.g*alpha);

> > I found references to cc.brcosa.jxs shader, but can't find any code

> > associated to it. do you have a link to it?

> > > check out the co.brcosa.jxs shader for ideas about how this might work.

> > > > Is there a way of seeing the cource code for jit.brcosa?? or at least

> > > > know what the algorithm is? specially for brightness...

On 11/5/07, Wesley Smith  wrote:
> basically, you just need to look at the fragment and can deduct what
> it would look like tin CPU source code:
>
> const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721);
>
> varying vec2 texcoord;
> uniform sampler2DRect image;
>
> uniform vec3 avgluma;
> uniform float saturation;
> uniform float contrast;
> uniform float brightness;
> uniform float alpha;
>
> void main (void)
> {
>         vec3 texColor   = texture2DRect(image, texcoord).rgb;
>         vec3 intensity  = vec3 (dot(texColor, LumCoeff));
>         vec3 color      = mix(intensity, texColor, saturation);
>         color           = mix(avgluma, color, contrast);
>         color                   *= brightness;
>         gl_FragColor    = vec4 (color, color.g*alpha);
> }
>
> wes
>
> On 11/5/07, Jaime Oliver  wrote:
> > Hi Wesley,
> >
> > thanks for your answer,
> >
> > I found references to cc.brcosa.jxs shader, but can't find any code
> > associated to it. do you have a link to it?
> >
> > best,
> >
> > Jaime
> >
> > On 11/5/07, Wesley Smith  wrote:
> > > check out the co.brcosa.jxs shader for ideas about how this might work.
> > >
> > > wes
> > >
> > > On 11/5/07, Jaime Oliver  wrote:
> > > > Hello,
> > > >
> > > > Is there a way of seeing the cource code for jit.brcosa?? or at least
> > > > know what the algorithm is? specially for brightness...
> > > >
> > > > any pointers are welcome,
> > > >
> > > > J
> > > >
> > > > --
> > > > Jaime E Oliver LR
> > > >
> > > > joliverl@ucsd.edu
> > > > www.realidadvisual.org/jaimeoliver
> > > > www-crca.ucsd.edu/
> > > > www.realidadvisual.org
> > > >
> > > > 9168 Regents Rd. Apt. G
> > > > La Jolla, CA 92037
> > > > USA
> > > >
> > >
> >
> >
> > --
> > Jaime E Oliver LR
> >
> > joliverl@ucsd.edu
> > www.realidadvisual.org/jaimeoliver
> > www-crca.ucsd.edu/
> > www.realidadvisual.org
> >
> > 9168 Regents Rd. Apt. G
> > La Jolla, CA 92037
> > USA
> >
>

could you say what the mix () function does or point me to info about it?

below is my partial inrpretation, if you can let me know if i am in

const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721); //set Lum coefficients

vec3 texColor = texture2DRect(image, texcoord).rgb;

vec3 intensity = vec3 (dot(texColor, LumCoeff));

// make a dot product of the colors and the luma coefficients

vec3 color = mix(intensity, texColor, saturation);

gl_FragColor = vec4 (color, color.g*alpha);

below is my partial inrpretation, if you can let me know if i am in
the right track:

void main (void)
{
       vec3 texColor   = texture2DRect(image, texcoord).rgb;
       // get the rgb colors of the image
       vec3 intensity  = vec3 (dot(texColor, LumCoeff));
       // make a dot product of the colors and the luma coefficients
       vec3 color   = mix(intensity, texColor, saturation);
       color           = mix(avgluma, color, contrast);
       color          *= brightness;
       // Scale the colors by the brightness
       gl_FragColor = vec4 (color, color.g*alpha);
       // set the new colors
}

Mix is a linear crossfade between arguments 1 and 2 based on the value

of argument 3. It's linear interpolation between 2 points.

> could you say what the mix () function does or point me to info about it?

> below is my partial inrpretation, if you can let me know if i am in

> const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721); //set Lum coefficients

> // make a dot product of the colors and the luma coefficients

> > basically, you just need to look at the fragment and can deduct what

> > it would look like tin CPU source code:

> > const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721);

Mix is a linear crossfade between arguments 1 and 2 based on the value
of argument 3.  It's linear interpolation between 2 points.

On 11/7/07, Jaime Oliver  wrote:
> hello again,
>
> could you say what the mix () function does or point me to info about it?
>
> cheers,
>
> Jaime
>
> below is my partial inrpretation, if you can let me know if i am in
> the right track:
>
> const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721); //set Lum coefficients
>
> varying vec2 texcoord;
> uniform sampler2DRect image;
>
> uniform vec3 avgluma;
> uniform float saturation;
> uniform float contrast;
> uniform float brightness;
> uniform float alpha;
>
> void main (void)
> {
>        vec3 texColor   = texture2DRect(image, texcoord).rgb;
>        // get the rgb colors of the image
>        vec3 intensity  = vec3 (dot(texColor, LumCoeff));
>        // make a dot product of the colors and the luma coefficients
>        vec3 color   = mix(intensity, texColor, saturation);
>        color           = mix(avgluma, color, contrast);
>        color          *= brightness;
>        // Scale the colors by the brightness
>        gl_FragColor = vec4 (color, color.g*alpha);
>        // set the new colors
> }
>
>
> On 11/5/07, Wesley Smith  wrote:
> > basically, you just need to look at the fragment and can deduct what
> > it would look like tin CPU source code:
> >
> > const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721);
> >
> > varying vec2 texcoord;
> > uniform sampler2DRect image;
> >
> > uniform vec3 avgluma;
> > uniform float saturation;
> > uniform float contrast;
> > uniform float brightness;
> > uniform float alpha;
> >
> > void main (void)
> > {
> >         vec3 texColor   = texture2DRect(image, texcoord).rgb;
> >         vec3 intensity  = vec3 (dot(texColor, LumCoeff));
> >         vec3 color      = mix(intensity, texColor, saturation);
> >         color           = mix(avgluma, color, contrast);
> >         color                   *= brightness;
> >         gl_FragColor    = vec4 (color, color.g*alpha);
> > }
> >
> > wes
> >
> > On 11/5/07, Jaime Oliver  wrote:
> > > Hi Wesley,
> > >
> > > thanks for your answer,
> > >
> > > I found references to cc.brcosa.jxs shader, but can't find any code
> > > associated to it. do you have a link to it?
> > >
> > > best,
> > >
> > > Jaime
> > >
> > > On 11/5/07, Wesley Smith  wrote:
> > > > check out the co.brcosa.jxs shader for ideas about how this might work.
> > > >
> > > > wes
> > > >
> > > > On 11/5/07, Jaime Oliver  wrote:
> > > > > Hello,
> > > > >
> > > > > Is there a way of seeing the cource code for jit.brcosa?? or at least
> > > > > know what the algorithm is? specially for brightness...
> > > > >
> > > > > any pointers are welcome,
> > > > >
> > > > > J
> > > > >
> > > > > --
> > > > > Jaime E Oliver LR
> > > > >
> > > > > joliverl@ucsd.edu
> > > > > www.realidadvisual.org/jaimeoliver
> > > > > www-crca.ucsd.edu/
> > > > > www.realidadvisual.org
> > > > >
> > > > > 9168 Regents Rd. Apt. G
> > > > > La Jolla, CA 92037
> > > > > USA
> > > > >
> > > >
> > >
> > >
> > > --
> > > Jaime E Oliver LR
> > >
> > > joliverl@ucsd.edu
> > > www.realidadvisual.org/jaimeoliver
> > > www-crca.ucsd.edu/
> > > www.realidadvisual.org
> > >
> > > 9168 Regents Rd. Apt. G
> > > La Jolla, CA 92037
> > > USA
> > >
> >
>
>
> --
> Jaime E Oliver LR
>
> joliverl@ucsd.edu
> www.realidadvisual.org/jaimeoliver
> www-crca.ucsd.edu/
> www.realidadvisual.org
>
> 9168 Regents Rd. Apt. G
> La Jolla, CA 92037
> USA
>


> > vec3 intensity = vec3 (dot(texColor, LumCoeff));

I suppose that given that intensity is vec3 the dot() function isn't

really a dot product, but the product of each element separately right

(as opposed to summing them up in typical linear algebra dot procuts)?

> > color = mix(avgluma, color, contrast);

I see the avgluma variable declared, but no initialization or

calculation before it is called in the second mix(), am I missing

> Mix is a linear crossfade between arguments 1 and 2 based on the value

> of argument 3. It's linear interpolation between 2 points.

> > could you say what the mix () function does or point me to info about it?

> > below is my partial inrpretation, if you can let me know if i am in

> > const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721); //set Lum coefficients

> > vec3 texColor = texture2DRect(image, texcoord).rgb;

> > // make a dot product of the colors and the luma coefficients

> > vec3 color = mix(intensity, texColor, saturation);

> > // Scale the colors by the brightness

> > gl_FragColor = vec4 (color, color.g*alpha);

> > > basically, you just need to look at the fragment and can deduct what

> > > it would look like tin CPU source code:

Two more questions:
(1)
> > vec3 intensity  = vec3 (dot(texColor, LumCoeff));

I suppose that given that intensity is vec3 the dot() function isn't
really a dot product, but the product of each element separately right
(as opposed to summing them up in typical linear algebra dot procuts)?

(2)
> > uniform vec3 avgluma;
> > color               = mix(avgluma, color, contrast);

I see the avgluma variable declared, but no initialization or
calculation before it is called in the second mix(), am I missing
something?

On 11/7/07, Wesley Smith  wrote:
> Mix is a linear crossfade between arguments 1 and 2 based on the value
> of argument 3.  It's linear interpolation between 2 points.
>
> wes
>
>
>
> On 11/7/07, Jaime Oliver  wrote:
> > hello again,
> >
> > could you say what the mix () function does or point me to info about it?
> >
> > cheers,
> >
> > Jaime
> >
> > below is my partial inrpretation, if you can let me know if i am in
> > the right track:
> >
> > const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721); //set Lum coefficients
> >
> > varying vec2 texcoord;
> > uniform sampler2DRect image;
> >
> > uniform vec3 avgluma;
> > uniform float saturation;
> > uniform float contrast;
> > uniform float brightness;
> > uniform float alpha;
> >
> > void main (void)
> > {
> >        vec3 texColor   = texture2DRect(image, texcoord).rgb;
> >        // get the rgb colors of the image
> >        vec3 intensity  = vec3 (dot(texColor, LumCoeff));
> >        // make a dot product of the colors and the luma coefficients
> >        vec3 color   = mix(intensity, texColor, saturation);
> >        color           = mix(avgluma, color, contrast);
> >        color          *= brightness;
> >        // Scale the colors by the brightness
> >        gl_FragColor = vec4 (color, color.g*alpha);
> >        // set the new colors
> > }
> >
> >
> > On 11/5/07, Wesley Smith  wrote:
> > > basically, you just need to look at the fragment and can deduct what
> > > it would look like tin CPU source code:
> > >
> > > const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721);
> > >
> > > varying vec2 texcoord;
> > > uniform sampler2DRect image;
> > >
> > > uniform vec3 avgluma;
> > > uniform float saturation;
> > > uniform float contrast;
> > > uniform float brightness;
> > > uniform float alpha;
> > >
> > > void main (void)
> > > {
> > >         vec3 texColor   = texture2DRect(image, texcoord).rgb;
> > >         vec3 intensity  = vec3 (dot(texColor, LumCoeff));
> > >         vec3 color      = mix(intensity, texColor, saturation);
> > >         color           = mix(avgluma, color, contrast);
> > >         color                   *= brightness;
> > >         gl_FragColor    = vec4 (color, color.g*alpha);
> > > }
> > >
> > > wes
> > >
> > > On 11/5/07, Jaime Oliver  wrote:
> > > > Hi Wesley,
> > > >
> > > > thanks for your answer,
> > > >
> > > > I found references to cc.brcosa.jxs shader, but can't find any code
> > > > associated to it. do you have a link to it?
> > > >
> > > > best,
> > > >
> > > > Jaime
> > > >
> > > > On 11/5/07, Wesley Smith  wrote:
> > > > > check out the co.brcosa.jxs shader for ideas about how this might work.
> > > > >
> > > > > wes
> > > > >
> > > > > On 11/5/07, Jaime Oliver  wrote:
> > > > > > Hello,
> > > > > >
> > > > > > Is there a way of seeing the cource code for jit.brcosa?? or at least
> > > > > > know what the algorithm is? specially for brightness...
> > > > > >
> > > > > > any pointers are welcome,
> > > > > >
> > > > > > J
> > > > > >
> > > > > > --
> > > > > > Jaime E Oliver LR
> > > > > >
> > > > > > joliverl@ucsd.edu
> > > > > > www.realidadvisual.org/jaimeoliver
> > > > > > www-crca.ucsd.edu/
> > > > > > www.realidadvisual.org
> > > > > >
> > > > > > 9168 Regents Rd. Apt. G
> > > > > > La Jolla, CA 92037
> > > > > > USA
> > > > > >
> > > > >
> > > >
> > > >
> > > > --
> > > > Jaime E Oliver LR
> > > >
> > > > joliverl@ucsd.edu
> > > > www.realidadvisual.org/jaimeoliver
> > > > www-crca.ucsd.edu/
> > > > www.realidadvisual.org
> > > >
> > > > 9168 Regents Rd. Apt. G
> > > > La Jolla, CA 92037
> > > > USA
> > > >
> > >
> >
> >
> > --
> > Jaime E Oliver LR
> >
> > joliverl@ucsd.edu
> > www.realidadvisual.org/jaimeoliver
> > www-crca.ucsd.edu/
> > www.realidadvisual.org
> >
> > 9168 Regents Rd. Apt. G
> > La Jolla, CA 92037
> > USA
> >
>

> > > vec3 intensity = vec3 (dot(texColor, LumCoeff));

> I suppose that given that intensity is vec3 the dot() function isn't

> really a dot product, but the product of each element separately right

> (as opposed to summing them up in typical linear algebra dot procuts)?

It is a real dot product in every sense of the word.

> > > color = mix(avgluma, color, contrast);

On 11/7/07, Jaime Oliver  wrote:
> Thanks, that makes a lot of sense,
>
> Two more questions:
> (1)
> > > vec3 intensity  = vec3 (dot(texColor, LumCoeff));
>
> I suppose that given that intensity is vec3 the dot() function isn't
> really a dot product, but the product of each element separately right
> (as opposed to summing them up in typical linear algebra dot procuts)?

> (2)
> > > uniform vec3 avgluma;
> > > color               = mix(avgluma, color, contrast);

> It is a real dot product in every sense of the word.

> dot(a, b) = a.x*b.x + a.y*b.y + a.z*b.z;

so then intensity has the same value in each element of the vector?

that is, if the result of the dot product is 0.73, intensity would

have values (since it is vec3)? and therefore:

mix would interpolate from 0.73 to R, 0.73 to G, 0.73 to B according

> > > > vec3 intensity = vec3 (dot(texColor, LumCoeff));

> > I suppose that given that intensity is vec3 the dot() function isn't

> > really a dot product, but the product of each element separately right

> > (as opposed to summing them up in typical linear algebra dot procuts)?

> > > > color = mix(avgluma, color, contrast);

> It is a real dot product in every sense of the word.
>
> dot(a, b) = a.x*b.x + a.y*b.y + a.z*b.z;

so then intensity has the same value in each element of the vector?
that is, if the result of the dot product is 0.73, intensity would
have values  (since it is vec3)? and therefore:
> >        vec3 color   = mix(intensity, texColor, saturation);
mix would interpolate from 0.73 to R, 0.73 to G, 0.73 to B according
to the saturation value??

> > vec3 intensity  = vec3 (dot(texColor, LumCoeff));

On 11/7/07, Wesley Smith  wrote:
> On 11/7/07, Jaime Oliver  wrote:
> > Thanks, that makes a lot of sense,
> >
> > Two more questions:
> > (1)
> > > > vec3 intensity  = vec3 (dot(texColor, LumCoeff));
> >
> > I suppose that given that intensity is vec3 the dot() function isn't
> > really a dot product, but the product of each element separately right
> > (as opposed to summing them up in typical linear algebra dot procuts)?
>
> It is a real dot product in every sense of the word.
>
> dot(a, b) = a.x*b.x + a.y*b.y + a.z*b.z;
>
>
> > (2)
> > > > uniform vec3 avgluma;
> > > > color               = mix(avgluma, color, contrast);
>
>
>
> wes
>

> so then intensity has the same value in each element of the vector?

Yes. This is shaderland hacking you wouldn't do on the cpu. GPUs like

vector ops. It could've been done some other way as well.

> that is, if the result of the dot product is 0.73, intensity would

> have values (since it is vec3)? and therefore:

> > > vec3 color = mix(intensity, texColor, saturation);

> mix would interpolate from 0.73 to R, 0.73 to G, 0.73 to B according

Yes.  This is shaderland hacking you wouldn't do on the cpu. GPUs like
vector ops.  It could've been done some other way as well.

> that is, if the result of the dot product is 0.73, intensity would
> have values  (since it is vec3)? and therefore:
> > >        vec3 color   = mix(intensity, texColor, saturation);
> mix would interpolate from 0.73 to R, 0.73 to G, 0.73 to B according
> to the saturation value??

> > so then intensity has the same value in each element of the vector?

> Yes. This is shaderland hacking you wouldn't do on the cpu. GPUs like

> vector ops. It could've been done some other way as well.

> > that is, if the result of the dot product is 0.73, intensity would

> > have values (since it is vec3)? and therefore:

> > > > vec3 color = mix(intensity, texColor, saturation);

> > mix would interpolate from 0.73 to R, 0.73 to G, 0.73 to B according

On 11/7/07, Wesley Smith  wrote:
> > so then intensity has the same value in each element of the vector?
>
> Yes.  This is shaderland hacking you wouldn't do on the cpu. GPUs like
> vector ops.  It could've been done some other way as well.
>
> > that is, if the result of the dot product is 0.73, intensity would
> > have values  (since it is vec3)? and therefore:
> > > >        vec3 color   = mix(intensity, texColor, saturation);
> > mix would interpolate from 0.73 to R, 0.73 to G, 0.73 to B according
> > to the saturation value??
>
> Yes.
> wes
>

jit.brcosa source