Converting to/from u32 sRGBA and HSLA

[Nic0w]

Hi everyone,

I'm new to palette and I'm struggling to understand how conversion works between different color spaces and encodings.
The doc make it seem very simple but as soon as I try with my use case I get an avalanche of Trait related errors :(

The data I'm trying to manipulate is in the form of an unsigned int. Ex: -7589836 which is color code #ff8c30 with an alpha channel value of 52.

What I want to do is parse this value as a color I can manipulate with palette. More specifically I want to convert that value, which I understand is sRGBA, to HSLA in order to modiify the Lightness component.

Here's the code I wrote :

let raw_value: i32 = -7589836;
let color = Srgba::from_u32::<Rgba>(raw_value as u32);
println!("{:?}", color); //Alpha { color: Rgb { red: 255, green: 140, blue: 48, standard: PhantomData }, alpha: 52 }
        
let hsla_color: Hsla =  color.into_color();

I get the following errors :

error[E0277]: the trait bound `Alpha<Rgb<Srgb, u8>, u8>: WithAlpha<f32>` is not satisfied
  --> src/flightplan/color.rs:40:39
   |
40 |         let hsla_color: Hsla =  color.into_color();
   |                                       ^^^^^^^^^^ the trait `WithAlpha<f32>` is not implemented for `Alpha<Rgb<Srgb, u8>, u8>`
   |
   = help: the following implementations were found:
             <Alpha<C, A> as WithAlpha<A>>
   = note: required because of the requirements on the impl of `FromColorUnclamped<Alpha<Rgb<Srgb, u8>, u8>>` for `Alpha<Hsl, f32>`
   = note: required because of the requirements on the impl of `FromColor<Alpha<Rgb<Srgb, u8>, u8>>` for `Alpha<Hsl, f32>`
   = note: required because of the requirements on the impl of `IntoColor<Alpha<Hsl, f32>>` for `Alpha<Rgb<Srgb, u8>, u8>`

I have tried multiple variations of the following code, including trying to call the various into_* methods (without success), importing all the traits the doc would refer to, ... I also tried reading palette source code but being also relatively new to Rust, the black magic you guys do with Traits had me lost in no time :/

Thanks in advance for any help you can provide,
Regards,

Nic0w

[Ogeon]

Hi, you seem to be hitting an unfortunate case with the error messages, but the solution should be relatively simple. Let me start by annotating your example with bit more explicit types to know what we are talking about:

let raw_value: i32 = -7589836;
let color = Srgba::from_u32::<Rgba>(raw_value as u32); // This is Srgba<u8> which is Alpha<Rgb<Srgb, u8>, u8>
println!("{:?}", color); //Alpha { color: Rgb { red: 255, green: 140, blue: 48, standard: PhantomData }, alpha: 52 }
        
let hsla_color: Hsla =  color.into_color(); // Hsla defaults to Hsla<Srgb, f32>, which is Alpha<Hsl<Srgb, f32>, f32>

Rust has this quirk where if you have a type with default type parameters, the defaults become strict requirements when used in a let statement. This means Rust will try to find an implementation of IntoColor<Hsla<f32>> for Srgb<u8>. Conversion implementations between color spaces generally don't convert the component types (it could probably be added case-by-case), so that implementation doesn't exist. Now, Rust will pick one of the matching implementation cases and give you a hint towards how to make it work. For some reason it seemed to have picked this one:

impl<C1: WithAlpha<T>, C2, T: Component> FromColorUnclamped<C1> for Alpha<C2, T> where
    C1::Color: IntoColorUnclamped<C2>,

It then proceeds to tell you how to fulfill C1: WithAlpha<T> in this case. I would guess it picked that because it's the one that would most probably be possible to fulfill. There could exit an implementation where the conversion actually works.

But for your case, all you need to do is to convert your RGBA color to Srgba<f32> as an intermediate format. So something like this:

let raw_value: i32 = -7589836;
let color = Srgba::from_u32::<Rgba>(raw_value as u32);
println!("{:?}", color); //Alpha { color: Rgb { red: 255, green: 140, blue: 48, standard: PhantomData }, alpha: 52 }
        
let hsla_color: Hsla =  color.into_format::<f32>().into_color(); // <-- notice the added into_format for changing the component type

The extra ::<f32> may be unnecessary if the type inference still understands what you want.

Also, I hope this won't scare you away. The conversion code may be weird by necessity, since there are so many combinations, but the errors are usually much more straight forward. I'll make an issue for trying to improve the situation and see if the documentation can be improved to show a case like this.

[Ogeon]

I opened #268, as mentioned.

[Nic0w]

Thanks for the answer ! I had to write it like that :
let hsla_color: Hsla = color.into_format::<f32, f32>().into_color();
I was also able to do the conversion back to sRGBA/i32 !

I'll accept the answer as it was very informative :)

[Ogeon]

Right, the transparency type is independent. Nice to see that it worked!