#apertus IRC Channel Logs

https://www.apertus.org/axiom-beta-roadmap updated

morning folks!

Good evening everyone! :D

Hello BAndiT1983!

great! thanks for asking!

2. Organizing data to avoid alignment holes 3. Problems caused by standard dynamic memory allocator (we already discussed as I believe)

hello

Hi alexM_ and sebastian :D

One more point, which I am not sure about though : instead of reading one item per cache line in the inner loop (in case of matrix for example) we can use all of the items

is it a good idea?

what is it about currently?

Yeah, I had a slight guess about it.

Kjetil_ : but isn't optimization for cache kind of different L2/L3 cache?

the source for all will always be the sensel data from the sensor

nmdis1999: hm?

I was wondering if the optimization for cache works differently for L2/L3

regarding cache, here's a quick exercise anyone can try

Yup

note that the Cortex A9 in the Zynq doesn't have L2/L3 cache it has an I-cache and a D-cache

Bertl : I didn't know that , thanks!

write down the execution time, then reverse the order of the two for's

nmdis1999: I guess is is less relevant as this should run on the Cortex. But, L2/L3 is usually shared between multiple cores. So if multiple cores require the same piece of data, the first core to request it will suffer cache miss penalty. But if the other cores shortly after need the same data they will then hit in the cache.

https://mgc-images.imgix.net/esl/Zynq7000_credited-9D62B659.png?q=80&w=1600&fit=max

yeah; didn't try this on ARM, but on a low-end x86-64 you can easily get a 20-30x slowdown after swapping the loops

It did explained how and why the execution time will be greater, also how we can use itemsPerCacheLine = CacheLineSize/sizeof(elementType) in our benefit :)

I'd say we shouldn't worry too much about cache at first; these optimizations are best done after getting a working proof of concept, IMO

Thanks, Kjetil that helps :D

Good Evening!

Are you on?

off for now ... bbl

hey TofuLynx, just for a bit

Hello!

Also, I'm implementing a pattern system, however, I have some questions regarding this

is this true?

but, for example , imagine this situation:

for example RGGB, you wil have R at offset 0, G1 at offset 1, G2 at offset width + 1 and B at width + 2

G2 at offset width + 0 and B at width + 1 :)

can you explain it better?

just like in the linear interpolation, you would start at index 1 of the data, then you wil get red at 0 and at 2

this is also what my implementation does

what about trello, supragy is using it, also nmdis1999

check it

why do you do the shift as index?

shift as index?

okk!

well, how do you suggest to change to the next row?

i would use index = 1 as starting point for red, or whatever color is first in the sensor

maybe 2 steps, first most data, starting at x 1 and y 1, so you can get it diagonally

yeah

it was for general linear interpolation, so you are between 2 reds

but for bilinear you should start at 1,1 or so, so you are in the middle of diagonal cross of pixels, can't remember the patterns curretnly

ah yeah it does start at 1,1 :)

ok, andrej, I have a query

imagine a RGGB pattern

and you need the red value for the Green0 offset

yep

now imagine a GBGR pattern

you basically grab the red value at down and red value at up, correct?

oops, my bad

https://github.com/codeplaysoftware/visioncpp/wiki/Example:-Bayer-Filter-Demosaic

GRBG

right one will get interpolated value

hmm?

my suggestion is to have some sort of balancing of values for now, not an expert, to be honest

correct

wait

where is the red value at index 3?

hmm can you repeat it? xD

there are also the cases and according interpolation patterns

bookmarked!

how do I replace the (_width << 1) ?

also width << 1 shouldn't be used in the loop, but calculated beforehand, it accelerates the processing

Ok! :)

don't know if it visible if you would replicate red value to the missing pixels on the left and top

Is it noticeable the change from bilinear to linear in this case?

yes?

I am trying to understand if is it neccessary some aditional processing for the linear interpolation at the borders

no, just known pixels / 2 between them

ah ok, but you are talking about weighting, what do you mean?

bggr, if we are looking at the first red pixel, which has 3 unknown pixels on top, top-left and left

my task would be, as excercise for you, to implement a unit test for downscaler, an example for bayerpreprocessor is already in the repo and also executing succesfully now

Hmmm, and do you think we need to test the downscaler for my project?

also a unit test is faster to execute, instead of an application

I thought bilinear interpolation didnt use weighting, as it does simple division

hmm I will do the unit test after I finish the patternoffsets

But isnt downscaler in a different pipeline?

shouldn't be, as every class should be callable without many dependencies

http://www.dmi.unict.it/~battiato/EI_MOBILE0708/Color%20interpolation%20(Guarnera).pdf

http://www.cs.tut.fi/kurssit/SGN-16006/kuva/SGN-16006_labwork.pdf

now it loade

alright, off for today, write here or in lab chat, monitoring multiple sources through the day

Sleep Well!

you too