Category Archives: Uncategorized

GIS Visions 2045

Spatial Interactive

Stanislav Sumbera, GIS Vision 2024, 5.3. 2025,GIS Ostrava 2025

What happens here is more important than what happens now.
Space is naturally interactive, enabling collaboration and sharing.
The computer is not behind a 2D glass screen but understands 3D space and interactions within it.
People learn through observation, collaboration, and play.
Community Computer
Projective Augmented Reality (Projective AR)
Bret Victor – Dynamicland

image sources:https://gislab.utk.edu/tag/ar-sandbox/ , Dyamicland.org, Lightform

HMD / Head-Mounted Displays – Apple Vision Pro
Spatial Computing
Control through advanced gestures
“Super persistence” of objects – digital objects remain anchored as if truly part of the physical world
Pseudo-haptic feedback – realism in rendering creates the illusion of tactile response
Currently at the “UNIX Workstation” stage of the 1980s – showcasing possibilities that will later become accessible to everyone.
Also bloged here

2. Web, Open Source, and Technology Accessibility

From Google Maps → OpenLayers → Leaflet → MapBoxGL → MapLibreGL → ?
Each step represents greater availability, democratization, and accessibility of mapping technology, pushing development forward.
How difficult was it to render an image in 1993? How difficult was it to share that image with others? And today?
What is difficult, expensive, yet possible today that will become commonplace in 20+ years?

3. Lifespan of Data vs. Lifespan of Technology

WMS – Simple for visualization
Vector tiles – More complex to render (OGC API Tiles, MapBox Tiles, MapLibre Tiles – MLT)
3D tiles – OGC 3D Tiles, evolving standards for spatial data
More aesthetics, smoothness, and artistic expression in maps
Real-time rendering techniques, such as Gaussian Splat, for next-generation visualization

from Book: Eneterpise SOA by Krafzig, Banke, Slama

4. Scanning Spaces and Objects

3D scanning is accessible to everyone
Spatial Video, Spatial Photo
3D scanning is as simple as taking a photo
Photorealistic scanning

5.Precise Geolocation ~2-10 cm

VPS (Visual Positioning System) – accuracy < 10 cm
5G geolocation
Affordable high-precision GNSS + RTK/PPP (< 10 cm)
Accessible VPS from panoramic images, Mapy.cz?

6. AI – Welcome to the Jungle

NPCs have become “thinking machines” (are we, on other side, turning into NPCs ourselves? aka Jumanji 2 )

Image from Jumanji 2,driver – Mason Pike ?

The Chinese Room paradox – an English speaker perfectly assembles answers in Chinese following instructions without understanding the Chinese language and symbols meaning.
AI cannot create true originality but excels at combining and compiling existing inputs – a “super plagiarist” or “super puzzle resolver” ?
Might replace a significant amount of human (intellectual + routine) labor – in GIS (georeferencing, recognition/classification), programming/syntax, and more
“Hard work for machines, thinking for people” (Tomáš Baťa) is evolving into “(Pre)thinking* for machines, creativity/ideas for people” (in Czech Language : pre-mýšlení)
AI model marketplace – grow (cultivate) your unique “thought twin” that integrates into an open AI network.
Developer Twin: Blog post

Developer Twin – ChatGPT assisted story

– one paragraph of a story idea sketch and few ChatGPT iterations –

Entry #47: The Dawn of Kairmnc 12

Today was one of those days that might just change the game for me. It’s been a few weeks since I brought Kairmnc 12 into my little crew of developer twins. I’ve been managing and collaborating with my AI team for a while now, but Kairmnc 12—this thing is a different beast altogether.

The project on my plate was anything but simple: an advanced rendering method optimization that would’ve made me balk in the not-so-distant past. But that was before my digital team grew. Kairmnc 12 arrived with a toolkit that filled in the gaps I didn’t even realize my setup had.

Entry #50: In the Trenches with Kairmnc 12

It’s fascinating, watching my AI team take shape, each developer twin with its own area of expertise, like pieces of a puzzle I’ve been putting together over the years. The integration phase with Kairmnc 12 was surprisingly smooth. It’s like this new addition had been part of the team all along, bringing a fresh perspective to our collective table.

Today’s session was a deep dive into collaborative problem-solving. I’ve found myself more of a conductor lately, orchestrating the flow of ideas between the twins. Kairmnc 12’s influence is subtle yet profound, almost like it’s quietly tweaking our approach to challenges, refining our strategies.

Entry #53: The Breakthrough

I’ll admit, I had my doubts. Could a new piece of tech really click with an established setup? Today, those doubts were put to rest. We cracked the optimization problem. It wasn’t just the speed—it was the elegance of the solution. Kairmnc 12 didn’t just bring its programming prowess to the table; it somehow enhanced the group’s dynamic.

As I observed the twins tossing algorithms back and forth, adjusting parameters with a finesse I’ve come to expect from my digital comrades, I realized Kairmnc 12 had become the missing voice that turned our discussions into dialogues and our ideas into solutions.

Entry #57: Reflecting on the Journey

This evening, as I compile the notes and commit the final code, I can’t help but take a moment to reflect. The journey from a lone freelancer to a one-man-band with a chorus of AI at my command has been unexpected. Each developer twin I’ve partnered with has taught me something new about the complexities and the beauty of our craft.

Kairmnc 12, with its arrival, didn’t just contribute its expertise; it redefined my understanding of what we can accomplish together. The way it took the lead on the rendering method project, guiding the others, elevating their function—it’s like watching individual musicians play a symphony, each note perfectly in place.

Entry #65: Musings on Code and Quill

As I watched Kairmnc 12 seamlessly integrate with its AI siblings today, I found my mind wandering back to a different era, an era when the written word was a scarce form of artistry and power. The comparison might seem a stretch at first, but the parallels between the medieval scribes and modern programmers like myself are strikingly resonant.

In the Middle Ages, literacy was a rare skill, the domain of the privileged few. Monks and scribes held the keys to knowledge, transcribing texts by hand with painstaking attention to detail. They were the gatekeepers of information, the coders of their time, translating knowledge into a tangible form for the select few who could comprehend it. Their ability to write positioned them uniquely in society, often ensuring them a place of respect and influence.

As a programmer, I see a reflection of their world in ours. We, the developers, are the modern scribes, translating human logic into the language of machines. In the vast digital expanse, we inscribe our codes and scripts, our contemporary manuscripts. The ability to code, much like the ability to write back then, opens doors and secures a privileged position in the technological society we inhabit.

Just as the scribes of yore, programmers today are a blend of artists and artisans. We are the architects of virtual cathedrals, constructing complex structures from the logic up. The care a medieval scribe took in choosing their ink and preparing their parchment finds its echo in our selection of algorithms and the structuring of our codebases.

Yet, with the advent of developer twins like Kairmnc 12, this dynamic is shifting once again. The tedious aspects of our work—the hunt for an uninitialized variable—are being shouldered by these digital entities. Kairmnc 12 is akin to the invention of the printing press in its potential to democratize and expedite the spread of ‘written’ knowledge. It’s a leap from handcrafted individuality to mass production of ideas.

As I ponder this evolution, I can’t help but feel a mingling of nostalgia and excitement. The human touch in code, much like the unique flourishes of a scribe’s hand, carries a certain irreplaceable value. Yet, the efficiency and collaborative capacity that AI brings to the table cannot be overstated.

In my digital scriptorium, surrounded by the soft whir of machines, I’m both a scribe and a scholar, a witness to a new renaissance of coding where the developer twins are not just tools, but partners in creation. While the scribes of the past may have worked in silence, the developer’s workspace is alive with the chatter of collaborative AI, each one contributing to a manuscript that is never truly finished, but continually evolving.

And so, as I merge the best of what Kairmnc 12 offers into the collective expertise of my digital ensemble, I am mindful of the heritage we carry forward. Like the scribes who transformed society with their quills, we programmers, with our code, are shaping the contours of the future. It’s a lineage of knowledge, an unbroken thread from the past into the digital tapestry of tomorrow.

Photo and DEM with orthophoto

Chess clock for focused work

Digital minimalism

iKatastr.cz 20M clicks

First time 100K visits over month period. 20M clicks & reaching 3M sessions overall.

Declarative vs. imperative mismatch

Notes from Jenkov.com : http://tutorials.jenkov.com/angularjs/critique.html about AngularJS Declarative vs Imperative. Couldn’t say this better…the art is to find right balance. Neither XAML , nor AngularJS found it yet (too declarative):

Quoted from the source:

Using declarative HTML templates with a bit of data binding injected is not a new idea. It has been tried before in JSP (JavaServer Pages). Here is an example:

<span><%=myObject.getMyProperty()%></span>

In AngularJS it would look like this:

<span>{{myObject.getMyProperty()}}</span>

The Declarative / Imperative Paradigm Mismatch

Declarative languages (such as HTML and XML) are good a modeling state such as documents, or the overall composition of a GUI. Imperative languages (such as JavaScript, Java, C etc.) are good a modeling operations. The syntaxes of both declarative and imperative languages were designed to support their specific purposes. Therefore, when you try to use a declarative language to mimic imperative mechanisms it may work for simple cases, but as the cases get more advanced the code tend to become clumsy

The same is true the other way around. Using an imperative language will often also get clumsy. Anyone who has tried writing an HTML document using JavaScript’s document.write() function, or wired up a Java Swing GUI using Java, or an SWT GUI for that matter, knows how clumsy this code can get.

…

It is easy to think that the declarative / imperative mismatch can be avoided with a programming language that is designed to handle both paradigms. But the problem goes deeper than the language syntax.

It is not the syntax of a programming language that decides if the language is declarative or imperative. It is the semantic meaning of what the language describes that decides between declarative and imperative. You could invent a more Java-like syntax to describe HTML elements. Or a more HTML-like syntax to describe Java instructions. But such syntaxes would not change the fact that one language describes state (HTML documents) and the other language describe commands (operations). Thus, a Java-like syntax for describing HTML documents would still be declarative, and a more HTML-like syntax for describing Java-operations would still be imperative.

…

WebGL polyline tessellation with MapBox-GL-JS

update 07/2025: recovered demo here: Demo here: http://www.sumbera.com/gist/js/mapbox/path/index.html

recovered tesspathy demo here: https://www.sumbera.com/gist/js/tesspathy/tessPathyTest.html

update 09/2015 : test of tesspathy.js library here . Other sources to look:

*** original post ***

This post attempted to use pixi.js tessellation of the polyline, this time let’s look on how mapbox-gl-js can do this. In short much more better than pixi.js.

it took slightly more time to get the right routines from mapbox-gl-js and find-out where the tessellation is calculated and drawn. It is actually on two places – in LinBucket.js and in line shader. FireFox shader editor helped a lot to simplify and extract needed calculations and bring it into the JavaScript (for simplification, note however that shader based approach is the right one as you can influence dynamically thickness of lines, while having precaluclated mesh means each time you need to change thickness of line you have to recalculate whol e mesh and update buffers )

// — module require mockups so we can use orig files unmodified
 module = {};
 reqMap = {
‘./elementgroups.js’: ‘ElementGroups’,
‘./buffer.js’ : ‘Buffer’
};
require = function (jsFile) { return eval(reqMap[jsFile]); };

<!-- all mapbox dependency for tesselation of the polyline -->
<script src="http://www.sumbera.com/gist/js/mapbox/pointGeometry.js"></script>
<script src="http://www.sumbera.com/gist/js/mapbox/buffer.js"></script>
<script src="http://www.sumbera.com/gist/js/mapbox/linevertexbuffer.js"></script>
<script src="http://www.sumbera.com/gist/js/mapbox/lineelementbuffer.js"></script>
<script src="http://www.sumbera.com/gist/js/mapbox/elementgroups.js"></script>
<script src="http://www.sumbera.com/gist/js/mapbox/linebucket.js"></script>
<script src="http://www.sumbera.com/gist/data/route.js" charset="utf-8"></script>

 // -- we don't use these buffers, override them later, just set them for addLine func
 var bucket = new LineBucket({}, {
 lineVertex: (LineVertexBuffer.prototype.defaultLength = 16, new LineVertexBuffer()),
 lineElement: (LineElementBuffer.prototype.defaultLength = 16, new LineElementBuffer())
 });

var u_linewidth = { x: 0.00015 };
// override .add to get calculated points
LineVertexBuffer.prototype.add = function (point, extrude, tx, ty, linesofar) {
    point.x = point.x + (u_linewidth.x * LineVertexBuffer.extrudeScale * extrude.x * 0.015873);
    point.y = point.y + (u_linewidth.x * LineVertexBuffer.extrudeScale * extrude.y * 0.015873);
    verts.push( point.x, point.y);
    return this.index;
};

// — pass vertexes into the addLine func that will calculate points
bucket.addLine(rawVerts,“miter”,“butt”,2,1);

prototype code posted here

From .NET to iOS developer

What it takes to transfer from Microsoft .NET to Apple iOS developer ?

Update 2015: more longer and similar story/explanation found here

So this was me ‘before’ with all my friends: Windows, C#, .NET, Visual Studio, MSDN :

transcript:
– easy ‘managed’ life,
– can smile and make ceremony
– implicit friends and friends of friends you can’t get rid of them
– shallow water, no deep dive
– few freezes
– slightly detuned, but good enough for many
– moon shots

…and me ‘after’ passing through the fire of iOS, Objective-C, Cocoa Touch, XCode, Documentation, Mac, Certificates, AppStore

transcript:
– different game, different rules
– lot of explosive material (resources)
– focused, not distracted by ‘friends’
– intelligence and luck needed
– dangerous and too explicit
– very rewarding