[HS]

Flipin Fantastic!!! 

[Korrelan]

It's alot smoother, even works nicely on my android phone now.

 

[ivan.moony]

Guys, thanks for feedback. You helped a lot 

[ivan.moony]

Did someone say i9? I'm sure someone said i9! How about dragging and animating contents with no scale down for speed? A bit of common sense optimization and it is fast enough even on my Celeron or mom's mid-speed android phone. Notice that there is still no Webassembly, nor asm.js. Only pure javascript, and I'm still surprised how fast it is:

https://e-teoria.github.io/Orbiteque/

I'd still like to hear what's happening on iPhones and tablets.

What's up next? Now I've got some work to do on the parser (I'm trying to implement logic operators), then to integrate it to Orbiteque to form a decent content management system (T-Lang as a Turing complete lisp-ish replacement for HTML, CSS and XSLT, all in one). This will make a space for a personal knowledge base usage (integrating a wisiwig editor then, I think I'm going commercial with this phase, if not before), which in turn will make a space for describing logic proofs and formal theories (Logos language), which will then make a space for crowdsourced site for sharing scientific materia with the world. A lot of things to do for a little me. I hope I'm sticking with this plan because somehow it sounds fine.

[ivan.moony]

Some programming adventures

• Just reporting successful fish eye bilinear interpolation, though with some pixel loss trade for speed. Bilinear interpolation does an excellent job with scaling bitmap with antialiased fonts.
  
  
• Also I played a bit with fish eye curvature, any value between -infinity and +infinity is now allowed. 0 means flat, 0.5 means perfect concave sphere, 1 means more concave ellipsoid. The value of 0.25 gives a nice less concave ellipsoid, optimized between readable text area size and boundary exposure (due to decreased magnification towards the edges). 0.125 curvature gives even bigger readable area, but boundary then becomes too reduced, so I stick to 0.25 curvature. The whole idea of using fish eye is to eliminate scroll bars, so I want boundaries to be visible too. Success here also.
  
  
• I tried to do some supersampling (rendering on double width and height, then scaling down to half), and I got almost perfect render without pixel loss, but drawing slowed down by a factor of 4 for a double resolution. Then I tried to implement what I could in asm.js, but things mysteriously  got even more sluggish than in pure javascript. I guess regular javascript JIT compiler optimization does a better job than me. Then I attempted specification of floating point number oversampling/undersampling, both bigger - slower and more visually correct, and smaller - faster and less visually correct. I expected a factor of `sqrt(2)` to show some visual improvement over the factor 1 with only doubling rendering time. Surprisingly, the best speed/pixelloss compromise was when there is no oversampling/undersampling at all. Wasted time until tablets speed up at least by a factor of 4.
  
  
• Then I tried to attack from another angle. Remember how I keep mipmaps of original bitmap iteratively halved way down to 1px * 1px? Now I implemented floating point number downscaling to support downscaling by a fractional factor between 1 and infinity. Expectedly, factors bigger than 2 introduce more pixel loss. Indeed, downsampling with factors between 1 and 2 (like `sqrt(2)`) give less pixel loss when rendering fish eye, but priorly scaling original bitmap to mipmaps by these factors introduce ugly pixel imperfect artifacts visible on regular square grids and regular concentric circles. I tried a few algorithms from out there to scale down mipmaps, but neither one did do the perfect scaledown, and they were all too slow considering proportionally bigger amount of processed mipmaps. Finally, I gave up, concluding that the best compromise is with the original mipmap scale factor 2. Also a wasted time until tablets speed up at least by a factor of 4, and then I still need to come up with perfect scaledown solution.
  
  

TL; DR;
Overall, only bilinear interpolation and variable fish eye curvature succeeded, but those alone are a big improvement from previous nearest neighbor scaling and fixed curvature of 1. The whole thing is even faster than the previous version without interpolation (where I used some weird tricks to increase readability), and it should be again fast enough even on mid-level smartphones (Chrome is notably faster than Firefox on desktops). Texts should now finally look perfectly antialiased without any visible pixelization, although with mostly insignificant pixel loss, with conveniently large oval area of visibility. From my experience, text sizes down to 10-12 points are still perfectly readable in a large area of central oval. For comparison, font shown in the below example is 18 points. I also noted some bugs with live resizing, fixing is pending.

Check it out on the same link as before: https://e-teoria.github.io/Orbiteque/.

[ivan.moony]

Wanna see something weird? The only thing I did was setting curvature variable from positive to negative `-0.25` value, and the code accepted it without any problems. It looks like a raytrace algorithm where bounding rays are bounced twice against the mirror.

[krayvonk]

Tripped out dudez!   

[frankinstien]

What you're describing is an ontological framework. I did work with Roget's Thesaurus where each class has satellites who have satellites, who have satellites, who have satellites. While you can only drill down so deep with Roget's framework you can extend to more subclasses that can relate to just about any kind of data. Which I did as well and am continuing to do work with. Here are some images:


here another example:


There are six main classes that drill down to 5 levels, but there is also an ability to describe words in various contexts that can build composite structures that relate to any kind of data inclusive of emotional signatures.

There is a more modern and complex ontological framework I work with now but Roget's Thesaurus was a proof concept and is used to give a machine an impression, similar to the image below:


The image depicts the first and second levels of Roget's classification scheme.


This image depicts the second and third levels of Roget's classification scheme.

Note the paragraph on the lower left-hand side of the UI. The radar maps on the right are the impressions or the span of ideas and concepts the machine can relate to from the paragraph.

[ivan.moony]

E-Fun project announcement

Finally been busy last week or two about this one. This is the most recent preview screenshot of a project based on fractal orbit.



It will be a content management system (CMS) with flat file support (no databases or server side scripting). It's based on bitmaps or vector graphic images uploaded from third-party source and configured in a JSON file for a hierarchy. It is still in a pre-alpha status, but you can visit a live demo here: https://contrast-zone.github.io/e-fun/. The demo is consisted of short instructions of how to use the system. Can already be used as a static documenting platform, but without hyperlink support.

Hyperlink support is still missing, but I'm on it. Probably going to be a JSON array of rectangle coordinates paired with web addresses, but I'm still considering options.

Mobile phones are of a questionable use in this case, aren't they? Anyone has a tablet to test it?

[HS]

I tested with a tablet. Dragging/sliding things is definitely easier with a mouse, touch screens are better for tasks requiring the accurate fast selections of distinct targets. So your current orbital mechanics seem best for use on desktop computers. Still usable (and fun) with both. 

[WriterOfMinds]

This is super neat. I tried it out on my laptop (which has two mouse keys and a touchpad).

I had a little trouble figuring out the navigation directions. Click-and-drag to pan around the central sphere was intuitive, but it wasn't obvious to me at first that I also had to drag in order to move to different spheres. Once I figured that out though, navigation was pretty easy.

And it all runs smoothly with no obvious performance issues, even though my laptop is old and sometimes struggles with over-complicated websites.

[ivan.moony]

Tx for feedback.

Yes, smaller sites load relatively fast. I develop it on my Celleron, so I take a care of performance as much as I can. Bigger sites perform as much fast, but initial browser loading chokes on them because of all pre-caching necessary for later usage speed. For this reason I have to cross off bigger sites on mobile phones that, for example, may be loading the demo for 8 seconds or more (about 1 second per page). Bigger number of pages extend the loading speed linearly proportional. Celeron loading speed is about 0.2 seconds per page, so desktops should be ok.

[ivan.moony]

The latest change (among others) in e-fun is improving loading speed at the expense of bound antialiasing. The most of the central oval area is still antialiased, only bounding regions are crispy now. By this, I hope I reduced loading speed on mobiles to a reasonable range (it's about 0.3 seconds per page now on my test phone).

I hope all this is enough to release the first beta version, so I did it here.

Is anyone interested in beta testing? You'd have to build and setup a small site of your own choice, and report possible bugs. You'd earn a free lifetime subscription to new versions of e-fun. Well, plans are to make the project free for trusty members of Ai-Dreams anyway, but I could make a use from some feedback on an actual use cases.

[ivan.moony]

fractal expression report: feb, 2022.

It's bee more than a year since the last report on this project. In a meanwhile, I turned it into a nice little headless CMS that operates on static HTML files (responsive page design supported). I changed a bit of appearance, used a few tricks, and finally got this:



These are the links if anyone is interested in taking a look or downloading it:

• You can test the demo here: https://fractarchy.github.io/fractagui/
• You can download the project here: https://github.com/contrast-zone/fract-exp

I decided to provide a special royalty free license for all the AiDreams forum members. Just override the default license, and use it, fuse it, take it, shake it, bell it, sell it, all free of charge and responsibility from my side of story. I hope someone will do something cool with it.

Have fun