JPEG XL

what about BitDepth 1?

I want to color the star, so I can add it to the american flag. But I need to clamp the values with some blend mode or something because the values are too crazy to modify by just adding some extra values

maybe there should be an option in jxl_from_tree for the level thing

I can't add color then. But it seems I can't do it either anyways D: I wonder if I can solve that as well...

perhaps

"the level thing" ?

> in either case it's still strictly speaking noncompliant because it goes above 16-bit buffer sizes > which you can't do without level10

why can't you add color anyway?

What is "level 10"?

codestreams are defined to be level 5 or level 10 level 5 codestreams have some restrictions that aren't applied to level 10 for example, `modular_16bit_buffers` header flag must be set to true in level5 codestreams

The blacks are way below 0, and vary a lot for each pixel. So I can't just do blend kAdd and add color, I will max out in each color channel or not even reach 0. And I can't really read the value. And re-calculating it isn't really possible since it's made from many layers.

I just meant, why can't you just do the same thing you did to get black/white but with other channels

for example, if you do the white/black thing but for the red channel only, it becomes red/black

The technique relies on the pixel output being clamped, while the values before rendering are not. So I can only really do colors available with Bitdepth 1.

White isn't 255, it's different values in the 100k~ range. And blacks are in the deep negative

That is possible, yes

I want #032d61 though

If I understand correctly, trying to use this technique without putting all values outside the available range gives you non-smooth edges like this:

Yep

I think you could do this out of range thing with only the alpha channel, then you could set any color your want inside the star, at least.

Hmm, sounds reasonable.

But I would be able to set both colors freely then, by blending with correct math

I think.

First attempts failed. Maybe I'm doing it wrong? I was setting alpha to only 0 or 255 before.

hm

Since red channel is first I might be able to use that (with Prev) and clamp green and blue. Then I can multiply 0 away red if I don't want it. So either max or 0 red, and any values for green and blue?

The blue in american flag is almost no red (3/255).

would using a palette help?

not that you can do it in jxl_from_tree (IIRC), but you could make a palette that makes 0 and 1 be black and white and you wouldn't have the gradient issue

I do want white on the white stripes of the flag though

would that be an issue with palettes?

<@265247121261854722> if don't mind, could you explain to me how to get an arbitrary angle that doesn't go thru 0,0? It's easy to make a diagonal that starts wherever (see image below), but I don't understand how to make it go at another angle.

```javascript let p = [] p[0] = {x: 768+Math.floor(Math.random()*50), y: 400+Math.floor(Math.random()*50)} p[1] = {x: 200+Math.floor(Math.random()*50), y: 200+Math.floor(Math.random()*50)} function line(p0, p1, under = false, region) { let k = (p1.y - p0.y) / (p1.x - p0.x) // y = kx + m // y - kx = m let m = p0.y - k * p0.x // console.log({k, m}) let flip = under ? -1 : 1 let y_add = Math.round(flip * -1 * 25600) let x_add = Math.round(flip * k * 25600) let min_y = region.min_y ?? 0 let min_x = region.min_x ?? 0 let s = `if y > ${min_y} if c > 2 if Prev > 254 - Set 255 - Set 0 - N + ${y_add} if x > ${min_x} - W + ${x_add} - Set ${Math.round(flip * m * 25600) + min_x * x_add + min_y * y_add}` return s } function tree_of_region(region, fail_value = 0) { let start = [] let end = [] if (region.max_x != undefined) { start.push(`if x > ${region.max_x}\n - Set ${fail_value}`) } if (region.min_x != undefined) { start.push(`if x > ${region.min_x - 1}`) end.push(` - Set ${fail_value}`) } if (region.max_y != undefined) { start.push(`if y > ${region.max_y}\n - Set ${fail_value}`) } if (region.min_y != undefined) { start.push(`if y > ${region.min_y - 1}`) end.push(` - Set ${fail_value}`) } start = start.join('\n') end = end.join('\n') return [start, end] } let s = `Alpha\n\n` let frames = [] frames.push(`NotLast if c > 2 - Set 255 - Set 0`) frames.push(tree_of_region({}).toSpliced(1, 0, line(p[0], p[1], false, {})).join('\n')) let region_from_pos = p => ({min_x: p.x - 25, min_y: p.y - 25, max_x: p.x, max_y: p.y}) let red = `if c > 2 - Set 255 if c > 0 - Set 0 - Set 255` for (let v of p) frames.push(tree_of_region(region_from_pos(v)).toSpliced(1, 0, red).join('\n')) s += frames.slice(0, -1).join('\n\nNotLast\n') + '\n\n' + frames.slice(-1)[0] console.log(s) ```

**Qon** _“Line through points”_ 2024 image/jxl 132 bytes https://jxl-art.surma.technology/?zcode=xVDLCsIwELzvV%2BxdCtvNo%2BlF8C5F8OC5SEVBULSI%2Fr1Jm5qkRK%2Fedmd2hpldna%2FHFppLv27vPcDpgHtcIgNigduuR1bqM1Ny97J3ZLlIMiybW%2Fdwu5IDkhqFnWCcG1xgwUqT93p6W8ftLFfruoYgE5pNWXKSxEkqwxBbT7DSUy6XVwqTCRHokj0wq5UvEp1RBM3Nv4nTP4yzj81C5NowVXEbFvSrDZP8c5s3

thank you :)

`y_add` and `x_add` control how the pixel values change with position

this handles lines that intersect the left and top borders of the image?

It is based on linear equation, it does `y = kx + m`

ah

If you do `x = ky + m` then you can get vertical lines as well

basically swapping `x_add` and `y_add` and maybe something more

But you can easily do `y = m` vertical lines with `if x > m` so it's not really needed

I considered doing `x = ky + m` when k is very large though, but I didn't need it for the star, the precision I got was enough anyways.

Surma website doesn't always report errors, sometimes the image just doesn't change. So that's why I randomize coordinates a bit so that I know if the image has loaded or if I got an error.

ahh!

And it doesn't make sense to have a horizontal split for code and output, displays are twice as wide as they are high and code is taller than wide. And image is square and doesn't even need 50% of a vertical split. And the code editor should be Ace, not a basic textarea... I'm considering PR'ing the website or making my own D:

honestly all this stuff makes my head spin

Did you run the javascript code?

not yet

brb

Also, the in browser editor would be better if it could also run JS and then run the output, so I don't have to run the JS outside browser and paste output tree description into surma. Because why would I write jxl trees when I can write js that writes jxl trees? :D

I can explain the confusing parts of the code if you ask. Though it's time to sleep so I'll answer when I can

I shall sleep soon too

A different kind of 'JXL Art', but my friend <@129256926088396800> made me a convention badge with my obsession in mind (Safety pin embedded in the back)

<3 <:JXL:805850130203934781>

Wow nice!

good job

Recompressed with `-d 1 -e 9`, cjxl v0.9.2 41b8cdab did not appreciate that <:KekDog:805390049033191445>

Wait what are we seeing here?

That looks pretty cool

See also this conversation from almost a year ago

There are some techniques that can be used to keep the numbers down. Maybe using numbers > 16 bits is the reason. I'm not sure why it happens there though, not where I expected issues.

The values for each step for the equation fields (arbitrarily angled cuts) are multiplied by 256 and 100 (25600) (should probably have been 255 * 100) to get steps that "jump over" the gradient of values 1-254 and get sharp lines like in Bitdepth 1. And the 100 for increased line precision, the k value means one direction gets smaller or larger steps. For slight slopes k != 0 but close to 0, there's a risk of getting a bit of gradient/fuzzy border. (25600 is just a big and small enough arbitrary constant)

Lower `Bitdepth` means I can use a smaller multiplier. But if I do an `if` on the `N` value and just jump to 255 or 0 instead of landing in the middle then I can reduce the constant by a lot. It would eliminate the need to accommodate the Bitdepth with the constant factor, it would instead just be a constant added/subtracted from the "starting" value ({x: 0, y: 0} when cut is over entire picture).

I thought about doing an `x = ky + m` equation instead when the `k` values for the `y = kx + m` equation are unreasonable might help as well? Though the values either have to grow fast in one direction, horizontal/vertical and slow in the other, when the line is close to horizontal and vertical in angle. So it might not actually help...

But near vertical and horizontal lines take up a very small portion of the image along one axis, the tree can be adjusted to only calculate the `field` where a given `x` or `y` value has both black and white sides. And the top left corner starting value can then be adjusted together with the equation to get smaller numbers without moving the cut. With a max image size of 1024x1024, the distance of moving from one corner to the other is 2^11. But a cut in bottom left corner will occupy a small section on the x and y axis, so in reality worst case is a distance more like 2^10. Extreme `k` values need a higher constant factor, but also reduce the impacted range on the x or y axis which kind of cancels out.

Since Bitdepth 8 is a constant of just 8 bits, and image needs 10 bits for coordinates we would need probably only need ~10 bits ( 2^8 + 2^10 ≈ 2^10) instead of the ~27ish bits I would guess I used for the star.

```console $ wget 'https://upload.wikimedia.org/wikipedia/en/c/c3/Flag_of_France.svg' $ convert Flag_of_France.svg -channel blue -fx 0 Flag_of_Belgium.png ```

there’s a bit of green in that blue band, so it doesn’t work 100%

oh, but that’s the old flag

with the new one, it works very well indeed:

(https://en.wikipedia.org/wiki/File:Flag_of_France_(2020%E2%80%93present).svg )

The proportions are incorrect! The Belgian flag has aspect ratio 13:15

apparently, > The national flag of Belgium was based on the French flag and even though it has an official ratio of 13:15 the unofficial 2:3 ratio is more commonly flown.

(https://flagmakers.co.uk/media/4fef4erl/flag-of-belgium-%c3%b4%c3%a7%c3%b4-a-brief-history-download.pdf)

13:15 is a very ugly and weird aspect ratio, who came up with that?

Swiss is 1:1

any deviation and you risk an “Aazeig isch dusse!!” on /r/BUENZLI

(example: https://www.reddit.com/r/BUENZLI/comments/18bj2d4/aazeig_isch_dusse/)

the Ohio flag isn't even a rectangle

this would be an interesting JXL art challenge <:heh:853085949667704883>

I was always fond of the aspect ratio of the flag of nepal: https://oeis.org/A230582 https://en.wikipedia.org/wiki/Flag_of_Nepal "the least root of 243356742235044x^4 - 1325568548812608x^3 + 2700899847521244x^2 - 2439951444086880x + 824634725389225" nice

could we make nepal's flag using jxl_from_tree, I wonder

Ohio looks also like the coordinates of the corners of the flag are at most algebraic

<!-- 8*tan(arctan(16/8)/2)-1 v --> is in the comment of the svg of the Ohio flag on wikipedia, Eisenmann's drawing looks interesting

this is a great fun fact. TIL

I can make the straight line segment shapes, but since jxl_from_tree language doesn't have layer referencing it's not possible to do (but JPEG XL has I think, so the language needs an update I guess) alpha masking to do shapes with alpha and non-BW slanted lines are sometimes tricky or impossible depending on the shape. And some shapes are impossible to do in a resolution independent way with the techniques I created for the star. It doesn't do arbitrary triangles, instead it can make axis aligned rectangles with an arbitrary cut which may be some triangle. In particular, I can make the outside of the 5 point star with this class of triangles but not the inside (the 2 legs pointing down at an angle).

wdym layer referencing?

I can't think of a way to make circles, except as polygons.

Rendering to a layer that isn't shown directly in final image, but can be used to influence later layers. I can do `if Prev > 0`, but that is only on previous color channel (which is also visible), I can't reference or test a completely different previous layer, only render on top of it.

yeah you can achieve that with a combination of RCTs and previous channel properties in the bitstream but I guess jxl-from-tree doesn't expose it

``` RCT 0: Reversible Color Transform. 0 is no transform, i.e. RGB. 1 is YCoCg. Higher numbers can be used. ```

What does "higher numbers can be used" mean?

there's something like 42 RCTs

some of which only swap channels around

And does jxl support larger color gamut spaces, HSL, oklab, oklch?

it supports ICC profiles so yes

I believe Qon wants to access previous *frames*, rather than previous channels. Is this something that can actually be done?

nope

but you can add an extra channel that is not rendered in any way, and do your hidden stuff there

moving it before color channels with RCTs

ah!

The wtf doesn't explain how to do that though.

Is there some example of this tech being used?

I don't think anything implements that

Are these in the code somewhere?

https://github.com/libjxl/libjxl/blob/main/lib/jxl/modular/transform/enc_rct.cc#L19

there's 6x7 RCTs, where high 6 being permutation and low 7 describing how to mix channels

ok ty

What about adding channels?

not sure if jxl_from_tree can do it...

I can't find anything in the spec about having extra channels, except for with palette or squeeze

> :22 `// 6 corresponds to YCoCg.` > wtf: `1 is YCoCg.`

wdym?

I'm making a patch to jxl_from_tree to show the idea, one sec...

adding an extra channel that isn't rendered. I see some stuff about extra channels but none of it seems like it could be used for this. I must be missing something.

there's kOptional

aha!, thanks

right, I was looking at completely the wrong stuff

``` RCT 0 HiddenChannel Bitdepth 10 if c > 0 if c > 1 if c > 2 if PPPrev > 433 - Set 309 - Set 581 if PPrev > 333 - Set 491 - Set 769 if Prev > 133 - Set 978 - Set 398 if x > 0 - W + 1 - Set 0 ```

code: https://github.com/libjxl/libjxl/pull/3295

very cool

in case you are wondering, the "Set" values were obtained by randomly mashing digits 😛

lol

I might have a crack at trying to fix the multi frame issue in jxl_from_tree I reported last week. I've been dealing with a sinus infection almost since then so haven't been in the mood for code.

Then I'll be able to implement patches support

So 1 hidden channel? More would be cool if JPEG XL supports that. 1 hidden makes color easy. 3 hidden would make arbitrary triangles in arbitrary colors possible. Would need `PPPPPPrev` for that though xD, the syntax design is a bit inflexible

I could do that...

Also probably there's a better way than adding Ps to go further back xD

How about Prev(1/2/3/4/5/6)?

oh, does the format itself support that? I figured jxl_from_tree exposed at least all tree stuff. That would be quite useful. Would `HideenChannel 1/2/3/4` for adding a larger number also be possible?

Should be yeah

That is an improvement at least. Not sure why it is relative channel indexing instead of absolute though

there's a limit on how further back you can go, though... don't remember what the limit is

before you said that, I had a silly idea: doing multiple frames, and using RCTs to mix which channel is first on each frame, so that you can do R, G, and B separately each having access to a hidden channel. Then kAdding them together.

ok, apparently 30 or so channels, that ought to be enough

enough for what? absolute reference syntax?

no, but for being able to go back as much as you want 😛

With more hidden channels I can compose more in a single frame. Elastic demand, I want all I can get and more q:

I'm making it go up to 8 hidden channels, and Prev6

Why Prev6 and not Prev11: so you can ref first hidden channel in alpha? and why 8 hidden specifically? Though I'm happy we are getting more and more readable syntax

I guess I could go up to 11 sure

as for 8... it's a number 😛

It certainly is <:KekDog:805390049033191445>

it seems enough to me for now 😛

``` RCT 0 HiddenChannel 8 Bitdepth 10 if c > 7 if c > 8 if c > 9 if Prev10 > 433 - Set 309 - Set 581 if Prev2 > 333 - Set 491 - Set 769 if Prev1 > 133 - Set 978 - Set 398 if c > 4 if y > 0 - N + 1 - Set 0 if x > 0 - W + 1 - Set 0 ```

of course there's way better ways of getting specifically that image

hooray

Should be enough for reducing the .jxl size by a lot for the 5 point star, I can now (when it is committed+approved+added to surma) do it in a single layer and don't even have to make individual triangles for features.

nice! <:BlobYay:806132268186861619>

trying to bring up my own version 😛

not sure I can get `publish` to work though

**Fake Mondrian** _“Test”_ 2024 image/jxl 103 bytes https://jxl-art.lucaversari.it/?zcode=bY6xCsIwFEX3fMXdRXjPRJMsDnZxElHBWUykgVJEgujfG2obTXV753IOya46gMQ6OOfbqj61rW9gxCpE56%2BxBpMQ4YIzltAC6E%2BTzgy2gw63N39nSpuSsl%2BBKfY%2BQpIdLXPDZTlLofwJleXRohdWfD%2BYMs7ZW7HaFCyt%2BfxeDfUzAWVvgwm4qGgQH4V4%2FCO%2BAA%3D%3D

seems to work 😄

https://jxl-art.lucaversari.it/ now I request to see something amazing! 😛

hooray

I'm on it!

**\_wb\_** _“Something mildly amazing”_ 2024 image/jxl 40 bytes https://jxl-art.lucaversari.it/?zcode=TYwxCoAwEAT7e8V%2B4CARbS200EpEhdRiTgxIEAm%2B30sh2M3AMFO7wFAfvJfYHmuMcsJSE5KXKx2whijs2FBrpTDe8iiXBTG6e%2FVBYtL%2BJ1zlzvHgtGNLgOqg%2FinAcPhIM0MZZjlly68X

nice

**Lonnie** _“Flag of Seychelles”_ 2024 image/jxl 133 bytes https://jxl-art.lucaversari.it/?zcode=lZA9C8IwGIRn%2ByveXQr5bl0c7OKkokLnYqMNSJQSRP%2B9adqEgNri9twldwfvvjgCStaqrqUumkpreQWWrJSp5d00kCfbVkltKqNu2j6UqrbuQtiIVJfGALOYqDOcYGl7BsAeiAcaPjEP3Fm7Vj6oj3SCxYLHQjiRwkEawFQMlPMBqAfCPfE8bJC4aWqwTwsPBGe%2FNzChYQTHVVOLfRyFQhLWPkf6G7%2FcjQFS2MAcMKedsP7T%2BbMUSvvUhWZ%2FpzhGoylEvqUyMbrVlY6H3g%3D%3D

The lack of AA along the edges is sad, but otherwise I am very pleased with this.

noice

I just managed to make it blurrier xD

haha. btw, here is how it looked like when I messed the channels up.

what did you do to do that?

enabled EPF and set the sigma to 10000

ahh

I don't think you can do that from jxl_from_tree

what if you just enabled gab

would that effectively antialias

a bit, but not enough

too bad you can't tell jxl to render it at 4096x4096 and then downsample it 😄

another funny trick could be to render 4 frames off by 1 pixel, and then blend them together xD

Could tell JXL that it's already downsampled and then apply 2x upsampling

gab should be renamed to fab

I tried, doesn't really work 😦

And maximum verbosity should be set to default

Default fancy upsampling doesn't look very blurry, so it's not very good at hiding the jaggies here

can you opt in to not fancy blurry as heck upsampling?

You can do custom upsampling, not in jxl_from_tree though

And it comes with some signaling cost

How do I use `HiddenChannel` with multiple frames? Do I add the header before each frame I want hidden channels for or is it same for all frames?

this version of jxl_from_tree doesn't work with multiple frames anyway

oh

fair

see this bug: https://github.com/libjxl/libjxl/issues/3264

also, you don't

ah no, you do, it's the same for all channels

*frames?

yup, sorry...

mhhh that can't be too hard to fix though... lemme try

yeah it wasn't 😄

Hooray

I *think* you can re-set HiddenChannel between frames, setting it to a different value or even 0, and it should work

Ok good. Is it live on your site as well?

also, I just pushed a version with multiframe fixed

lemme see if it's actually true

yup

you might need to reload

yup hooray

``` Bitdepth 1 RCT 0 NotLast Alpha HiddenChannel 1 if c > 2 - Set 1 if c > 1 - Set 1 - Set 0 HiddenChannel 0 if c > 2 - Set 1 if c > 0 - Set 0 - Set 1 ```

and this does what you'd expect it to do

(I think you still get the optional channels, but not first)

<@179701849576833024> I assume the trees are meant to be deterministic, right? xD Surma's site and your fork

😭

I assume they don't make the same jxl file?

1 byte difference

I guess there's some different default somewhere

that's good

It's just the default tree when you first open each site

``` Bitdepth 8 Orientation 7 RCT 1 if y > 150 if c > 0 - N 0 if x > 500 if WGH > 5 - AvgN+NW + 2 - AvgN+NE - 2 if x > 470 - AvgW+NW -2 if WGH > 0 - AvgN+NW +1 - AvgN+NE - 1 if y > 136 if c > 0 if c > 1 if x > 500 - Set -20 - Set 40 if x > 501 - W - 1 - Set 150 if x > 500 - N + 5 - N - 15 if W > -50 - Weighted -1 - Set 320 ```

yeah

RCT 1 -> RCT 6

not sure what changed

I asked about that a few hours ago

https://discord.com/channels/794206087879852103/824000991891554375/1208388240642674758

Yeah, going to 6 on your site fixes it, on Surma's it made a nice traffic light themed version

I think that mapping changed at some point. The Surma site hasn't been updated in a long time, maybe since before that changed.

lemme update the default on my site

done

IIRC a long time ago, how RCT works in jxl_from_tree was changed.

hmm, looks like surma's site should have that change.

Yeah RCT numbering changed

apparently it doesn't 😛

rip

Yeah it never ended up getting updated on surma's site

Old numbering followed some old FUIF convention where 0 is RGB, 1 is YCoCg, and then the real jxl rcts which were added later started at 2, so everything was shifted by 2. That was removed at some point because it was not matching the spec and a bit silly, but yeah you have to adjust the values

Setting `HiddenChannel` multiple times doesn't work for me. I have the same amount of channels as the first (when I only set it for the first frame) on all frames. If I set it to the same value on each frame it breaks.

mhhh

you're right, it doesn't do what I thought it would

not sure how easy it is to fix though

Also, prettyfy makes HiddenChannel jump into the tree in a weird way I thinbk

I have absolutely no idea how Prettify is supposed to work

I'm sure it shouldn't turn valid code into invalid code though

🤔 😛

... yeeeah

someday I'll RIIR the whole thing

xD

**Qon** _“Colored octagram {8/3}”_ 2024 image/jxl 396 bytes https://jxl-art.lucaversari.it/?zcode=7ZhPa8MgGMbv%2BRTeS0CNRr0Mxi47jDLYYefSZrRQurGVsXz7aVYlmlfTbf0LUgrxeaPPz9dXW7xdvy1nxf1qsWg2d8vZZtOskSymr9uH2ce2KFYvaI5uEMEFQiV6araIcq6fd7rSjzZQs66xi8iuYWNE%2BE1JvJH18%2BN780mIFrAdpVOwU5ymepITpSc6WQSyC9SDgGUL1V0HDnSIdXGdGNgp3s3P8V7Ql4A3QnFwNzjylyXP2ft%2Fmk4GCOkH3P65Fq68Fo6w7Geez1A99m9g3gR5E1z8JjhdxV%2Fg1EPtHP%2BU8ymRT4l8SlzTKXHmM%2BEqMjR6w6FE%2FIaD9fJsoiIYtOrn3LxQ%2B%2FluB6kp0RRNEMGUhUvwBV5ePOu3WfCydS85VZWkvqWhGJxlLTg2SBJl%2BaEpARrHo5igdehtgACLNmIRgUpgWTDKRLzYCOX6A5S3wasgszZqNtVfEDEJOYLp6rTCBKsaIjKoFDZtE6YJ3BHg1JL3mRWvJMcwWXcdGLNuk9ZJ8FH0%2BO4J8TlRREXTM094jExhj0nsMQ07kWjheHuQUjms81%2FxTk7KS6gQpt6%2FAQ%3D%3D

So colors works now that we have hidden channels. And I can easily use numbers that aren't super crazy. And with 8 channels I can have shapes defined with 8 lines.

Each pair of points with index `i` and `(i + 3) % points` defines a line, which splits the image in 2 regions. 8 lines in 8 hidden channels. Each line splits the channel into 2 regions, non-positive and positive. If a point is positive in at least 6 out of the 8 hidden regions then it is "inside" the star.

My code generates the region counting test, so I can make any star {p/q} where p = 5 to 8 and with any valid q by just adjusting the p and q values and the region inclusion number.

It can also fairly easily be colored differently for each region.

very cool

**Qon** _“Regions shown heptagram {7/3}”_ 2024 image/jxl 453 bytes https://jxl-art.lucaversari.it/?zcode=7ZdLS8QwEIDv%2BRW5L4G8HxdBvHiQRfDgubiVXViqaBH992bbJm2KKRuzlYLd0zy%2FyWSYLbk%2Bvu4LcHvY7crqZl9UVXmECmxf6rvivQYIPpQ1pEIAcHiGT%2FAKGgDtzyr3b%2BUHwdaCgddNqOpQVaEqQ1WEKu%2FU%2FgReJiYa1rhamWh6LjyWFYa1rk7m8peNZNaahEezRmGNq5OxucyAltxXSiO5tabhsaxRGO4vU7FZ9mkd1%2FzjypjPkttK6iOv1DQ7khRGNZ5WZPIvvlTrZq2b9Z8363KrtI5q5lHlzGapPSU1kVNokhzJCYNYf4XYPa9087xqjUY5qxpYuXBWObAyZxTuffbla23hxrZKeXuOz85%2B8jxaDzdswEFSYKp9CZ5GQ2Ma4YJg6Wgsmcb1EEeppsb%2BKXQ4%2BhMOTeAIDXCESSZ7HEnDbbx8YkmmjPAonIoanYwbQRrY2UMMLwpRhpUQ%2Bhs%3D

Someone should try to make a svg to jpegxl converter

already exists

**Qon** _“heptagram {7/2}”_ 2024 image/jxl 274 bytes https://jxl-art.lucaversari.it/?zcode=tZM9T8MwEIZ3%2F4rbK0tn%2B%2Fy1IKEuDKhCYmCOaFArVQHRCMG%2FxzRxarcGxVCiDHnfyz33Eed697Jp2M12vW675abpunYHlq2e%2B9tm3zMO920PUmvGtk%2FwCFfgGYQriLvX9k1gcJBN2ufS5dLm0uRSj3IomQToLHDs6ix7Vk4h%2F5tmqnEF9Lyx%2F1SpUPVXu79YE4WGLnE2%2FqW%2F4%2FN4xN3hiA%2B2t9G1iUvTuyZxVTR1%2FEc%2BpkZXsACBkoYh3kf%2FK%2FIQIphQuERyiJFFdSwOQjqd4Axp8hRpqkTjP9CIHKWDS01SmoiT1TivEpoQCrWeRhV1tMUJzUgd7gjDalg%2BKVfKOnFY3NyveLJ5biyixU8%3D

<https://github.com/wwww-wwww/spline>

I noticed that this one also has a {7/2} hidden inside of it.

Yeah, and {7/1} :D

^_^

what does it actually do then?

Using splines for everything? What techniques does it use to match shapes? Is it exact?

very not exact

it just turns svg splines into jxl splines

things like shape filling are ignored

https://grass.moe/splines/

There's an explanation there

here is an example of its output

What was the source svg?

and what are the sizes of svg and jxl?

I don't have that on me, I'll post it here in a few minutes if I find it

But it's an image that Jon has used a few times when presenting about JXL.

Bottom of the page <https://jpegxl.info/> https://jpegxl.info/jxl-architecture.svg

Generally the JXL is a lot smaller, I seem to recall 30% of the original, but also missing all solid colours

The SVG size is also like, uncompressed XML

Gzip can shrink it a good bit

<@179701849576833024> > R is undefined Would be nice with actual error messages. Also sometimes I get > e is undefined and sometimes I get no error message even though it doesn't work, so it looks like it maybe worked but gave same result as before if there is already a previous generation left over. And sometimes it doesn't work, but when I reload the page and try again it works. Seems like `e is undefined` is sticky and sometimes requires a page reload for the page to work again or it will just say that even for valid code.

yep, I noticed that

I have no idea what's up with it

and tbh I am not familiar enough with the JS code (or with JS in general) to truly have a shot at fixing it

hence this 😛

but if someone wants to - and is able to - PRs are welcome...

Rust can be compiled to js and run in the browser or?

yup

Maybe I should learn Rust someday then :o

well, to wasm, not to JS

but effectively the same

Well, then you need JS to run the WASM ;P

what does the `(x1)` in the leaf nodes mean?

Seems like an end point?

it's a multiplier for the residual

doesn't really matter for jxl art, since all residuals are 0

ah

it's pretty much only used for modular lossy

It's a way to quantize things, which we're currently only using in a simple way (same quantizer for everything) but in principle it could be useful to do adaptive quantization where the weights aren't signaled explicitly but derived from the tree.

**Qon** _“heptagram {7/3} and CA rule 110”_ 2024 image/jxl 753 bytes https://jxl-art.lucaversari.it/?zcode=7VrLSgMxFN3nK7IvgbzmtRFEBBcyCC66LnakhVJFi%2BjfO3VmYh6ddjIDFfV0d5Pcc5OT%2B8ikudw8rxbkZr1cVtur1WK7rTY0J%2BXT7nbxuiPrR%2FpAL6jghNY%2FRu%2BrHZVJYkmceINq6e6lehOibtq3dDJ35cIVc1fMXFG3Yt8UzMB0pF4Sq9eMLc24vTBne5mJr4amiZXXZkgI50LG6nQt36ZDFDMZ31AIG610eKuwA2ffAY9yMBmvBAqGJWJEN6Ib0f1XizV8C74FCiaEV9RHDWopaimCHbUUvgXfAgXTPkQRbXA1UAAKpiScSf9Q4DCPwzyCH4d5%2BBZ8CxTgMA9XAwWg4HfexCP%2FwPNAASgABWOU2teghf0YVJ1Ioa1ObuvIYToZOWg%2BtaFGpXtv6o0FQYL5BR0i6AhufZRrYwqU9J7ZHtEIdHuW%2BsOz6plGFNTQe7Z%2FsPJhSx1p49QDbNB%2BHtpH8TzZuJeKTdX5MIglnVHBuSmF71ZSn9d9OpdW%2FmapSrjWHZ6OxWM%2BntAi46YmqBF4KsvtAiNloTMDKA8BsqOAQibKAhRKiUwaBkUPoKWRStWN5rHmZ755natEkrgdcxlhskasKfkE

Could be half the size if I had 1 more hidden channel available, I think.

I like these recent evolutions.

Which ones are included in "these recent evolutions"?

Everything that uses the hidden channel trick

It's so useful!

jxl-oxide gave me this, not sure what's happening

That also looks interesting, now the question is what's happening

Glitch art :)

Well either the bitstream is not conformant to the spec (int16 overflow or bug in jxl_from_tree that causes it to write something bad), or there's a bug in libjxl, or there's a bug in jxl-oxide.

wait, maybe I'll force i32 buffer

these do tend to go over the int16 limit

it's not conformant if that's the case

I'm using like 21 bits I think

would probably be useful to be able to tell jxl_from_tree to do the appropriate things to allow int32

Yeah, wrap it in a container and add a jxll box saying it's level 10

ok that fixed it

wonder how many bytes that adds

size of image is 1024, multiplier for precision is 1000. So I get ~(10+10) bit numbers

Something like 50 bytes iirc

rip

and... i32 buffer was faster than i16 buffer

what's happening here

50 bytes is like 10% of the image

yeah but even much smaller images like the Seychelles flag go above int16

Well I guess the main thing jxl_from_tree should do is signal in the codestream that modular 16 bit is not enough

That would not add any size iirc

This is not allowed in Level 5 and naked codestream is implicitly level 5, but that's probably where jxl-oxide is looking to figure out what buffer type to use

yeah it just uses modular_16bit_buffers

So it would still be non-conformant but it would render correctly in any decoder, since any sane decoder will look at the codestream fields.

Non-conforming yet functional is where all the fun happens

**Qon** _“swedish heptagram {7/3} with precision 50 and CA rule 110 snow, 256x256”_ 2024 image/jxl 751 bytes https://jxl-art.lucaversari.it/?zcode=7VtNS8QwEL3nV%2FS%2BBJp%2BJO1FUBH2IEXwsOfFVltY1kWL6L%2B3rW3IR3dtWlhR3546SeZN8jKZSbPppsrr0gtiTtZF9VTW3eNVVefFoSlPyOXuUG7JusrzYn9dbvf7YteUZs%2F17fa1JtWj9%2BBdeMwnXvOj3n3RAsSd1NelnTBUMi7UykSv9Lkm%2B8Qw0Eh3L8UbY01RWzLIvi6nupjootDFqBfN7g9dkA35TL3YVe%2BrbSbbtcKGtjJlPT9tEc1uZBMbTod01VHmsDdto8jOmIZsWGel8anCDJx9BgzKwaS7EiiYFoixurG6sbr%2FarKGb8G3QMGC5eX0UoNcilyKxY5cCt%2BCb4GCZS%2BiWG1wNVAACpYEnEX%2FUGAzj808Fj828%2FAt%2BBYowGYergYKQMHvPIlH%2FIHngQJQAArmKGlXSvsQGpohlIzqJKpOYOr40biW0K6dWsH6iBZXtWblA2Ns%2FfVYYg3AqmBWhXUsFOo2lkAFxj3cExqW7pGh%2FnCvjnTDCWrqQdw%2FGPm0oc608d0NbdB%2BHtpn8bzY%2BPDUx1yZlj4kYuatvFhmynclem%2BamkAN3lSkkQzfkRsUNaCYEGKACp2hAi3DJH4ssYIxLHoCi4dE%2FfCCp6n8nOIIlNJeJJJa383wSjfMWUfs5GnRCKBBEjYMfAI%3D

I think that is small and imprecise enough that it fits in 16 bits

jxl-oxide:

Not exactly the same

I could reduce dimensions and precision slightly more though. But I like high res and precise more than following some 16-bit rule 😈

I guess we need a debug thing that decodes in int32 and keeps track of the actual range of decoded numbers so we can see if it will overflow int16 or not

jxl-oxide with forced i32

so... it overflowed

But I guess only a bit

Yeah I reduce the numbers little by little until I saw constants slightly below 2^15

Let's just make jxl_from_tree set modular_16bit to false. That's technically not allowed in a naked codestream but I don't really like how we defined that anyway. It would make more sense to me to let the implicit level be determined by the codestream header (image header and first frame header), instead of just being 5.

The precision constant has less and less visible visual effect as it grows, but with the CA rule on top we get some chaotic behavior that can drastically change a lot of pixels from just a single pixel changing on the star :D

butterfly effect in practice

would anyone object if you changed it in the next version of the spec? 😄

So in some future edition of 18181-2, I think we should revisit how the implicit profile/level is defined. I would prefer to define it so that whatever can be derived from the image header and first frame header defines what the implicit profile/level is.

Technically having that many hidden extra channels is also not allowed in level 5 btw

num_extra <= 4, yeah

It's at most 4 extra channels beyond the 3 color channels iirc

So in principle a strict decoder could also choke on that

But I think we should allow it, the spirit of the level box is that it allows a decoder to tell early if it can decode or not, and some info might be hidden far away in the 100th frame or something...

Anything the image header or the header of the first frame says can still allow a decoder to fail fast if it doesn't support it.

(in any case software decoders will likely just support all levels, so it's a bit academic, until we have hardware decoders and a hardware profile which will be much more limited but they'll make sure to explicitly signal their profile/level and the container overhead doesn't matter for those use cases)

**Qon** _“Bug report: non-deterministic output. And I don't understand where the gradient is coming from”_ 2024 image/jxl 106 bytes https://jxl-art.lucaversari.it/?zcode=lZHfCsIgFMbvfYrzAsJ0f9hVUBHsIiToYtcjrQljjZKot88tNZ1dNMGL73z%2BvnPUWnLVAs0LVAl5aRUQWqKNVFwMul6idTe0Daok56Lftk3fiw4IYle1b%2B4KyTOcYAUpAr0wHIXSUfmkjEUnYc3Et8gP66vCbC0ON%2FHIdGE86LfSFjPlj6jxqLGNH0uY7dyReNR4iCWMd2HTOk5xw8wbxbELoeCZzSulbgafixjiM%2FQ%2FJvEZMmPsJQLq5b6M6Z1Z%2Fumxtd4kIAv0Bg%3D%3D

<@179701849576833024> if I press `Run` over and over without chaing the code the colors change. Also, I don't understand at all where the gradient is coming from since I only ever set values in non-hidden channels to 0 or 255.

<@853026420792360980> The pattern above generates a section of the turing machine pattern for rule 110. The full pattern would require a bit more repetitions, but it seems to be actually possible to generate the pattern without explicitly encoding it bit by bit.

yea, jon mentioned a way to do the repeating pattern that I didnt' realize could be done

Wtf...

Will check later

Can also bump up the hidden channel limit

I invented arbitrarily angled lines after I made my CA jxl art, so at that time I didn't know that this specific technique was a possibility, I was thinking about some way more complex way to generate the pattern.

YES! xD

Surprised Qon doesn't have the JXL Artist role yet

I'm new here, only 2 weeks~. Also, I have only invented a few jxl-art techniques thought to be impossible so far <:KekDog:805390049033191445> I need to do more to catch up

I know this bug. Didn't know it wasn't fixed yet. Add RCT 0 and it goes away. Otherwise it ends up selecting an RCT based on uninitialized memory 🙂

I was going to say, it only seemed to have a few colors in the random results

**Qon** _“Turing machine pattern parts for rule 110”_ 2024 image/jxl 103 bytes https://jxl-art.lucaversari.it/?zcode=lZHRCoIwFIbvz1OcFxg4U%2FEqKAm8CIkKvJZcbSAmNaLevmluba6LHOziP%2F%2B%2B%2F5xt%2B%2ByIAZSilhzDOIGciQuXSMMU1kLWrFP1FFZNxyvIRV2zNuNV27IGKRRXua3uEsQZT7jEBaBaBA9Mqqh4UKMVDkKbgW3RH9ZXudlK7G7sEalCf9BupaxiLH9ESXpNdHxfIsXGHPFH9YeYw1gXHlv7KWaYaSM%2FdibkPPP4Sgszg815DLWZ8D8msBk6YfQlHOplvqxQO9L802JLtalDJvAG

`RCT 0` fixed it!

so maybe it was `RCT undefined` without that

but uh why gradients

I think there's also a bug with RCT and HiddenChannel

RCT mixes in the HiddenChannel instead of just doing ops on RGB

<@179701849576833024> I guess the normal RCT needs to get an offset in the channels it operates on, currently it acts on the HiddenChannels...

ah I didn't see this message

so it's deadly undefined thing

I thought I avoided that

Hidden channels have higher indexes than RGB channels, and I apply RTCs before I move the hidden channels in the front

I'm an jxl-artist now! :D

Do we just RTC 0 by default?

That's what the wtf says

So that was my assumption

But it doesn't really happen huh?

Well, easy to fix I guess

We should, but I guess we don't atm

I keep reading RCT as randomised controlled trial

An oddity I ran into. I have this on a hidden channel: ``` if y > 0 - N + 8947849 - Set 8947849 ``` This should simply make each pixel on that channel have the value `8947849*(y+1)`. Then I can do this in a color channel: ``` if Prev3 > [8947849 times N] - Set 255 - Set 0 ``` which should make the Set 0 happen for the first N rows. And this is true for values of N from 0 to 22. But when I try 23, the Set 255 happens at y=15. Above 23, the row at which the switch happens does go up, just slower than N. E.g. N=96 makes the switch happen at y=66.

I know that the channel values on each row are going up as they should, because they overflow exactly where they're supposed to.

here is the full image code if someone else wants to have a look: https://jxl-art.lucaversari.it/?zcode=RY7BCsIwEETv-xVzrpSmbYLJRdBeehJRwbM1axsoRWoU_HtNWuntzVuGnWN1hqCd85YfvoOm2lnLQ9Vdh4F75HRxNnghqGbXdh5SCyJ3xw0bLJT_oSDKEjT9i5FkQR5Gfpfb5vm7aaWNKZWQlOLEHoVSM4nYakfmIdQmmYtJj2wXqSbXxZnzi0-cAqTYYwVt5FpLE3NozPkL

in the meantime, - I fixed RCT 0 - added up to 16 hidden channels - fixed the 16-bit buffer thing

hooray

if the increment constant is 1, my code works flawlessly, but otoh I don't get the overflow in the middle of the image like I want. So there is something odd that happens with large numbers, even well below the point of overflow

do you have some way to reproduce that?

I sent you a picture

this one

that one is fine now 😉

It was a guess, I didn't say I know it is the case

ah ok 🙂

I published a picture but it hasn't appeared here :o

with `8947849 * 119`, the if is true at y=66, but with `8947849 * 120`, it happens at y=120 instead. I'm very confused.

Testing 16 channels xD

It's {15/7}

It's like 8kb as .jxl, I will use some channels now to reduce the size instead of maximizing polygon count

It looks amazing if I may say so myself <:BlobYay:806132268186861619>

that does look very cool

Qon, have you ever had issues like what I'm experiencing, when using huge values that overflow?

I'm trying to use overflow to create mirror-symmetry

What is the issue?

It has symmetries

and it is green and blue

the problem is that I can't get it to shift from green to blue where I want it to

Where do you want it to shift?

at y=96

Not what I tried to create but looks cool

neato

> /* blue */ Wait we DO have comments in jxl trees?!?!?

only on the website

it removes them before feeding the text to jxl_from_tree

https://jxl-art.lucaversari.it/?zcode=RY6xCsIwGIT3_yluroSkMZU6KGiXTiIqOKv5bQIlSK2Cb2_TVrsd3x13dyhOULT1reVH65BT6a3lULhLCFwjpbO3kStFJfvKtTC5IvJ33LDGpNKf0EQywbV-MRIZ4b7h93xzfcaQMejMFYYqqSGwXMScwJFb6CwblepbqoY5THaqBtywnWA2MNffHic__TV07TvMumtRxazQRsUD4r-fyC8

oooh! smart

Nah, jxl_from_tree also allows that.

oh ok

**\_wb\_** _“Flag of Sweden, kind of, using default palette colors”_ 2024 image/jxl 50 bytes https://jxl-art.lucaversari.it/?zcode=C3IOUTDgcsosSUktKMlQsOBySc0pSQxIzEktKUnlCs9MAQkaGHB5pGamZ5QomAKZXJlpCpUKdgqGlpZcCgpQjhGYA%2BZWwOWQBIzgAgoKugrBqSUKxmZoAoamXFjkkeTQzMYwGc1cFFPhcgA%3D

Using colors from the default palette can save some bytes

**\_wb\_** _“The default palette. First 4x4x4 colors (0-63), then 5x5x5 colors (64-188)”_ 2024 image/jxl 35 bytes https://jxl-art.lucaversari.it/?zcode=XYuxDkAwFEX39xX3ByQtKiYDBqMg6SzpQxOD4Q38vUaQsJ1zc25XDVBUenG8yYKcal5lbMeVRZisd2HUsaGG%2FbwIkpjITzhQQBsCAu%2BBVUAggoW%2BqWdBlv6LW7LksqdTr33%2Fik4%3D

These colors are available if you use palette colors outside the palette, in particular if you do a zero-color palette.

How would `DeltaPalette` interact with `Alpha` and `HiddenChannel`?

No idea, probably poorly but it may be doing something useful by sheer luck

We might need to fix how these interactions work

now do DeltaPalette, Alpha, HiddenChannel, and Squeeze at the same time...

there's a lot of options in jxl_from_tree that I've never seen anyone use

hm. wouldn't be too hard to add regular palette mode to jxl_from_tree, right? Then, if I understand correctly, you just need to add whatever colors you want to the palette channel, and you can use them very cheaply in the rest of the image. would save on space if you need to use the same colors multiple times in a tree.

Binary search in modular arithmetic is breaking my brain <:SadOrange:806131742636507177>

Too tired and there's so many weird cases to keep track of

Yes, maybe DeltaPalette should take some options (nb of colors and nb of delta entries, currently it just does 0 for both) and then you can have custom palettes and delta entries, which should allow cool stuff.

I haven't the faintest idea how this delta stuff works. Guess I should read the spec.

(e.g. just generating a nice palette via some tree and using it to recolor grayscale jxl art)

Delta entries are palette colors that are not an absolute color, but an offset w.r.t. a predicted color.

DeltaPalette also has as a parameter which predictor it is relative to

So you can e.g. have DeltaPalette with the AvgW+N predictor, and then the 'palette color' (0,1,-1) will use that predictor for Red, the predictor plus 1 for Green, and the predictor minus 1 for Blue.

There are also default delta entries in the default palette, they are at the negative indices.

So e.g. palette index -1 means delta entry (0,0,0), i.e. just use the DeltaPalette predictor in all channels with no changes.

It's funky stuff that allows you to get nice gradients while being in a palette mode too

Aha, cool beans. So if I have a prediction tree, and that tree predicts the number -1, that effectively means using whatever predictor DeltaPalette is set to

Yes

very cool

I dunno what it is set to by default, maybe that weird AvgAll thing

I'm looking at the code for jxl_from_tree, seems like setting the deltapalette predictor isn't exposed at the moment

Yeah nothing is exposed, it should be easy to add that though

I'm gonna have a lot of fun with this

here's a question, is the "Gradient" predictor so named because it's good at making gradients? 😄

Yes, it predicts linear gradients in any direction perfectly if the bit depth is precise enough to not have the integer rounding causing issues.

It's just N+W-NW (with clamping that doesn't trigger in gradient situations)

**Lonnie** _“I definitely have a clue what I'm doing”_ 2024 image/jxl 33 bytes https://jxl-art.lucaversari.it/?zcode=C3IOUTDgcsosSUktKMlQsOAKz0wB0kamZlweqZnpGSVgJldmmkKlgp2CoQGXggKQXQFjKyjoKrgXJaZkpuaVKOgaoosY4VNuBDcWJKWr4KegbQRhhSvomgIA

**Lonnie** _“Look at this very sensible thing that makes a lot of sense”_ 2024 image/jxl 36 bytes https://jxl-art.lucaversari.it/?zcode=C3IOUTDgcsosSUktKMlQsOAKz0wB0kamZlweqZnpGSVgpktqTkliQGJOaklJKhdXZppCpYKdgqEBl4ICkF0BYyso6Cq4FyWmZKbmlSjoGqKLGOFTbgQ3FiSlq%2BCnoG0EYYUr6JoCAA%3D%3D

Yes, very gradient <:KekDog:805390049033191445>

I love trying to figure out a large code base in a language I've barely used.

**Tirr** _“Gradient, 45 deg”_ 2024 image/jxl 28 bytes https://jxl-art.lucaversari.it/?zcode=C3IOUTDgcsosSUktKMlQsOQKz0wB0kamZlweqZnpGSVgJldmmkKlgh1QpYICkFkBZeoquBclpmSm5pVAueEKuoZccAW6Cn4KhkAyOBVsCgA%3D

**Tirr** _“Gradient, idk 63 deg or something”_ 2024 image/jxl 30 bytes https://jxl-art.lucaversari.it/?zcode=C3IOUTDgcsosSUktKMlQMDTgCs9MATKMTM24PFIz0zNKFEwNjbi4MtMUKhXsgEoVFIDMCihTV8G9KDElMzWvBMoNV9A15IIr0FXwUzACksGpYFMA

**Tirr** _“XYB colored gradient”_ 2024 image/jxl 45 bytes https://jxl-art.lucaversari.it/?zcode=TY0xC8IwEIX3%2BxVvEwqhJqWhk0M61CmDCm1HMdFmESk36L%2F3CFE63eN7991Ns6NTf8GeXOIQX7ygozEFmaa1dIzpsTBabYjSHTccZLMETXUFt0NVk8I5chYETRvUiCdozki8Tz4ASHyXqDCs15Dik3%2BNV95LqUxu%2FSZo%2BosKI5rypbP2Cw%3D%3D

**Tirr** _“Sun in the sky”_ 2024 image/jxl 78 bytes https://jxl-art.surma.technology/?zcode=i4h04gpyDlEw4HLKLElJLSjJUDA04ArPTAEzjEy4PFIz0zNKIGyu4IKczLxULiMFA0ogl6GRBYUmWBhQaICpIcWeAIYIkGFoYGimYMHlmpcCDRyuzDSFZAU7oAoFBSjTEMjUVQhOLVEwMjWAs3UtDbggLEsDAwA%3D

<@179701849576833024> splines don't work on your fork; maybe something is wrong in recent version of jxl_from_tree

Totally possible

It's not like it's tested or anything 😛

Take into account that spline area is limited in level 5 and current libjxl does check that (while the old surma libjxl didn't)

this didn't work either

Very fat splines like that are likely not valid level 5 so won't get decoded

yeah, fair

Oh but it just doesn't pass them, it seems

that's what I was thinking

splines don't appear at all

even short ones

Yep

**\_wb\_** _“Spline doesn't get passed”_ 2024 image/jxl 14 bytes https://jxl-art.lucaversari.it/?zcode=4wpyDlEw4HLKLElJLSjJULDgCs9MAdJGpmZcHqmZ6RklYCZXcEFOZl4ql6GCASVwyOvnAhFGpgbAQDHgcs1LgQYLl65CcGoJUAoA

14 bytes, that's definitely without spline

**\_wb\_** _“Spline does get passed ”_ 2024 image/jxl 49 bytes https://jxl-art.surma.technology/?zcode=4wpyDlEw4HLKLElJLSjJULDgCs9MAdJGpmZcHqmZ6RklYCZXcEFOZl4ql6GCASVwyOvnAhFGpgbAQDHgcs1LgQYLl65CcGoJUAoA

Yeah something must have been missed when refactoring the enc params passing

<@794205442175402004> can you look into it?

Sure

**Jon ;)** _“Splines are fixed!”_ 2024 image/jxl 36 bytes https://jxl-art.lucaversari.it/?zcode=4wpyDlEw4HLKLElJLSjJULDgCs9MAdJGpmZcHqmZ6RklYCZXcEFOZl4ql6GCASVwyOvnAhFGpgbAQDHgcs1LgQYLl65CcGoJUAoA

hooray

meanwhile im still staring at the palette code trying to figure out how to make it do what I want it to

<@179701849576833024> Please please please please fix the web tool so its error handling doesn't make it seem like it was designed by an evil genius doing his best at torturing developers. - There's sometimes no indication of errors, it just doesn't update the image. - The error message, if it appears, doesn't tell me what went wrong or what line caused the error. - Sometimes when it fails on input, the webpage is locked in a corrupted state and will fail for valid code. This means I have to reload the page before every Run to make sure there is no previous runs silently interfering with my run. - New fun bug!!: I just spent a lot of time debugging my working code because it sometimes fails valid code with comments included! The submitted message fails with the comments, but produces an image if you just remove the comments! So now I can't actually have comments in my jxltrees to make them even slightly readable and debuggable.

**Qon** _“Red {13/6} with white CA rule 110. Naive brute force region checking.”_ 2024 image/jxl 2648 bytes https://jxl-art.lucaversari.it/?zcode=7dxLb9tGEAfwuz4F7wEBLh8idSnQBgVyKIyiLeCzESu1gMANWqFov30pR5T5EANRlmTX%2FuWU9XpnlzPzn9eO95f3v0XJ7Hp1u76LQpLmsw%2FL1e9366%2F%2F%2F2G1vl1%2BqWeq2fefv9zdzD6sbm%2BX9%2B%2Fvbu7vl5%2BjUMyu%2Flj%2FdPPXerb6FH2MvotCOYvqf3H063IdpUXxMGrm5g%2BjZjbpzBV75h5HPfL16Oc%2Fl38X9U82v9nebTuV75lqiHWP01vQPcHj8u45t4uyAxfl7UVpb1HDpeGyrL0sdL4ofP3Uqx2tzeA63ozjsGXe5kfx1Y%2B7X3ncJPTGyeQVobfpkEI8tkmf5KQlDWvSDmsaOTTjtDcOvXHSHS%2B6w6o7LLvD%2BT45DLUxjOliayIbm0jHJoZK8Mio3vle1qmK7qkuu3ne3fwse%2FRU8Cmk%2Btr7jRWDtSPKShneojKMSB%2Fbz8v2ET6%2FgS8f%2BdRnPtXIMSaRGhA9LEhgd9ldbGd32d1T2d3DDC2ogRqoPRFqh2GLzF%2BTzA8T8mv88sM%2B9cg9BrsdVXKUTcgmsF2Iw93JJkAN1GQTZC6bkE0clz7warwaC8erkTmv9iK92lFuDNRADdSmQu0obGH7U9l%2BFJ%2BfvPngGCfph3Y54XIC2%2BWWgh%2BXE6AGaso4ZC63lOS4nODVWDhejcx5NZcToAZqoOZywuXEJf9SQjYhm%2BDuZBNkLsSRTYAaqMkmsP0tZhOnSB%2FYXXaXAWB32d3LBriU4ZUowymkf8JTDfuhz%2FFetP5o%2FdHYriAtctcfDWqg5u6HzBVGJGU6Gng1Fo5XI3NeTUcDqIEaqLlZc5miP1o2wd3JJshciCObkE2AGqjJJmQT%2BqPZXXaX3cV2%2FdGUQX%2F0c%2FRHn6EfWglSCVKspgRJ5uJzJUhQAzWpMLYrQbK77C4DwO6yu0qQlEEJ8nwlRzGDmIG9EjNwE2IGyvAKY4YzBAl0l%2B5eRHfPoKxnOe6wV6C%2FnbfVtDR4W00nifTZ22qgBmqatlQnVSdll95W49VYOF6NzHk1Xk0rMqiBmuttt0LeVpNNyCZkE2QuxOFrZROgBmqyCWz3h43sLrvLALC77K4%2FUqAM3lZTglSCFKspQZK5%2BFwJEtRADdSkwrIfJUh2l91ld9ldJUjKoATpbTUxg5hBzIDtYgbKIGbwthrd9bba%2F%2FFttQu8paZ3QO%2BAhEnvAJlLkvUOgBqoqUdhu94BdpfdZQDYXXbXPQBlUEvVOyBmEDOIGbgJMQNlEDPoHaC7egdecO%2FA%2BXsFBO4Cd4ZX4M7fCdwpg8Cd7tJdgfvLr7DDIAzC4PM6vjN%2FR%2FO%2FepuP9RZhQ%2Flh0393G15F76KQpHkz8892ZjN3vZnLq2w73NCKQyjzdF7uSCbTSRZZ2aZYposwnzcEFyP02ivyIm1%2BvZq6fdzfPpSLNNuxqJxOr8ehLM%2FnVWjozafTq%2FKkaNHLa%2FakedYQLPYRjL9JMC2TpEUwTcpFqIqGYD6d4CJpczAkZZIvqoZedsQBa3k%2B0itrbQi77033k0uL%2BZh6zdvSCCEvk923hqlne9f%2F1jxU1U5Zkv3kipCOoikr2qKIsxpL6YOyHA6fnn7EeRaKKixm%2FwE%3D

**Qon** _“Red {13/6} with white CA rule 110. Made to test how much I could reduce previous size this image at 2648 bytes.”_ 2024 image/jxl 443 bytes https://jxl-art.lucaversari.it/?zcode=nVVNb9swDL37V%2BheCBAp6usyYA0K9FAEwzYg52BxZwNFGrRG0f772oklS4q9Vc4pNPUeHymK%2FLn5zUS1aw9dw0AgVfd1%2B7fpLv9v2%2B5Qn3qPrb4%2FnZp9dd8eDvVx0%2ByPx%2FqJgaq2z93D%2FrWr2kf2h31jYCrW%2Fzj7VXcMlTpb3qfPlveKxKdmfJOV0ffWj5f6TfVfhpNxtNFFMy5PlsrJAKmCCZ7qHEHyiyCKQZiBfJWuYTKGQZIRXFLdBq7B2PHB5jAWb%2FjEt3fhyBQEMlsUIyALes3Al4LklEUQXxpMSuPvIbuWrE1GU6emSbK9zneKgv89Oan2GCjHUAbxVKKAKsO6FcrTKuG8KLtekynXpFekIdI8IMsLFhJT6xOjcpWyHOLmdeN63Xah71Yw5pM2TIuPMMS27OayYkbPezQVd4OPrIzGIgcwhNoESlFOqWS8nLhBB1p7QrfAFyNIoT9uS8PzPDwYhzKUyJTzZRWSRNqGAanL%2BSyJeBFRXx4k6QnVHCH%2FJyEakew5YRzYsN2onNCJuIIgjCBnPZ9cIVBhxGf6boCQL87TodJL7aXj2wAgI6ZNXqrtJs%2BVwNrQLGKeTk1b8eo1SRVfBZf9W8Jzs3z9%2BWT9wUmCsuCqTw%3D%3D

The {15/7} at 8kB made before should also be like 500B with this new code, which is an even better improvement. New code uses one more hidden layer for composition though so it can't generate stars with 15 vertices, I don't have enough hidden layers :(

So I achieved my goal at least.

The comment bug is in jxl_from_tree then I guess

**Tirr** _“Sun in the sky (smaller)”_ 2024 image/jxl 73 bytes https://jxl-art.lucaversari.it/?zcode=pZBNCsIwEIX37xTvAoHJoKXduKgoLsUK6lJMtAGtRXN%2FTH%2FwAmFg%2BBYzH7x3vtQ4rI8U1CE638eWVnAKbgRdYOfDo40Tbz%2FXl9%2B%2FvzS6LMYFNP0zdB5KyRlYLTMNpWQKhkyZIVJJHDQJhFoINp2bC0K488ZVuiJntAkNGx%2FTj%2FzZVIKJKpEf

well this is still not within Level 5 limits

**Tirr** _“Sun within the Level 5 limits”_ 2024 image/jxl 61 bytes https://jxl-art.lucaversari.it/?zcode=i4h04gpyDlEw4HLKLElJLSjJUDA04ArPTAEyTA2NuDxSM9MzSsBMruCCnMy8VC4jBQNKIJehkQWFJlgYUOoEM0pNAAYIkDY1NFAw4nLNS4EGDVdmmkKygh1QXkEByjQEMnUVglNLFIxMDeBsXUsDLgjL0sAAAA%3D%3D

We should add a way to set the colorspace of jxl art to a HDR space. Currently it uses the default, which is sRGB.

If possible: oklab, oklch & HSL color spaces would be nice to use in jxl art, if it could be configured per layer. So that nice gradients can me made in a fitting colorspace instead of sRGB or rgb at all.

I mean XYB is a modified oklab if that's close enough

I meant the image header colorspace enum, which has things like Rec2100 PQ or HLG. So it will be displayed in actual HDR instead of being clipped to SDR white.

For nice gradients, XYB should work, or even just YCoCg (which is RCT 6 in the new numbering).

this is a gradient in XYB color space, changing only Y

**Tirr** _“Changing everything in XYB”_ 2024 image/jxl 52 bytes https://jxl-art.lucaversari.it/?zcode=i4h04gpyDlEw4HLKLElJLSjJULDgCs9MAdJGpmZcHqmZ6RklCqaGRlxcmWkKyQp2QJVQhiEXl76WgpO6gpY%2BSKgSLKegAGRWQJm6Cu5FiSmZqXklMBk%2FXT8%2FuKQfnDbkguvSVQhX0DUEUsGpJUAnGIAtiSDeEpBxumjmGaEZF4lqHMQFECXmBgYA

seems like Alpha cannot be used with XYB

What are these “levels”?

**Tirr** _“Various colors”_ 2024 image/jxl 44 bytes https://jxl-art.lucaversari.it/?zcode=i4h04gpyDlEw4HLKLElJLSjJULDgCs9MAdKmhkZcHqmZ6RklYCZXZppCsoIdUCWUYcjFpa%2Bl4KSuoKUPEqoEy%2BkquBclpmSm5pUA5YGiFVDRcCBXVyE4tURBF2wYUGcEuk4%2FBV0cegzAGiKxaoCoMDQ2MAAA

Reminds me of when I was trying to make an image of all 16bit colors, then realised it would be ludicrously large

there are profiles (currently only Main profile) and levels defined in the spec which limits size and/or features, and they are mainly to provide sane resource bounds for decoders e.g. limiting cpu and memory usage.

Level 5 is sufficient for web images, whereas Level 10 has quite loose limits which can be used in authoring workflows

XYB gradients are quite fun to play with

uhhhhm

Is this list avalubale somewhere

Wait, huh? It says Level 5 supports any channel except `kBlack`, I would've assumed you'd want that for CMYK image viewing, although it is fair to assume it's only meant for authoring software

This good enough?