Updating WordPress is kind of pain. I can completely understand why many people do never update their (non-personal) sites. This is not a large WordPress installation. One site, roughly half a dozen plugins, one theme, and that is it. Nevertheless, today I made the effort to back up the data base and files and to update everything. Two plugins failed to work properly afterwards and it took me two hours to fix everything. However, don’t get me wrong. The heaviest problems I got did not originate from one of the plugins itself, but from the way I used it. Meaning, it was my own fault. Still, a pain.

A few weeks ago I wrote about my experience with VirtualBox and hardware-accelerated OpenGL using an Ubuntu guest OS. This post here is an errata.

The downgrade of the GuestAdditions only downgraded the driver of the virtualized graphics card that much, that OpenGL had to fall back to a pure software rasterizer. Thus, this is no solution at all.

With a current GuestAdditions OpenGL works somewhat. However, it does not work very well. You only have to do something in the grey area and everything crashes (including VirtualBox itself if you are lucky). For example, the Freegut usually available as installation packages in version 2.8 does not work at all. The current release candidate in version 3, however, does work.

Honestly, I have no idea if the whole thing works at all. The frame rates are not convincing. To conclude: this is not a solution and for sure not a replacement for a real computer with real hardware and a real installation. Sad.

The ESF-funded junior research group VICCI dealt from 2012 until the end of 2014 with the development, control and integration of cyber physical systems (CPS) at the Faculty of Computer Science of the Dresden University of Technology. The scope includes smart home environments and supporting people in the ambient assisted living.

Today, I am writing about Visualization in heterogeneous and distributed infrastructure. Well, this sounds more advanced than it is. Is simply is about remote visualization.

A first prototype for compressed video transfer was successfully integrated in a collaboration project with the HZDR Dresden by a co-advised student project. This work was presented on the international conferences SuperComputing 2013 (Denver) and 2014 (New Orleans). Both presentations focused on the PIConGPU research project by the HZDR, was an ACM Gordon Bell Finalist at the SC2013. This shows the clear applicability of our approach.

The video transfer, being the crucial part of the whole approach, was extended by multiple different compression techniques. In addition and worth a special mention is the bachelor thesis of Christoph Träger, which aimed at latency masking via image interpolation and extrapolation at the displaying thin client.

ba_traeger_idee

The core idea is latency masking via image interpolation on the display device. Based on the original image (left) the target image (center) is approximated. Re-projection of the image data allows for this approximation (right).

The prototypical software component for the video transfer is called RIV. The current state of the project can be downloaded from the VICCI website.

The implementation of the image interpolation for latency masking can be downloaded from the website of the bachelor thesis of Christoph Träger. Important: all rights on that source code remain with Christoph Träger! The source code presented there may only be used for teaching and research. Any further use requires the consent of the original author. The TU Dresden has the right for additional use of the source code.

 

The ESF-funded junior research group VICCI dealt from 2012 until the end of 2014 with the development, control and integration of cyber physical systems (CPS) at the Faculty of Computer Science of the Dresden University of Technology. The scope includes smart home environments and supporting people in the ambient assisted living.

My work package for visualization and visual analysis has within the project investigated three essential aspects and corresponding solutions:

  • visual analysis of complex, multi-dimensional, multimodal, dynamic space-time data,
  • visualization in heterogeneous, mobile and distributed IT infrastructure, and
  • implementation of visualization systems and components.

Today I am writing about the visual analysis of complex space-time data.

teaser

Visual analysis serves as administrative overview of a current CPS, mainly for security reasons, as assistance during development, and the operation of the system. Particularly interesting are out-of-the-ordinary (erroneous) behavior and the formation of emergent system properties. For this a visual exploration with minimal previous assumptions is necessary. For example, certain data, like forces acting upon joints of a robot arm, be visualized more effectively by representations in geometrical context. This assumption however reduced the generality of visualization.

I thus developed a corresponding visualization of data collected by the CPS using coordinated views of continuous-time scatter plots, continuous-time parallel coordinate plots and temporal heatmaps. This application is capable of interactive real-time representation of generic multi-dimensional data and offers the means for a visual analysis. The developed system was published in the journal Computer Graphics Forum, the leading European Journal on Visualization. In the context of the evaluation, live data from our laboratory CPS war visualized, presented and discussed with a broad audience.

  • [DOI] S. Grottel, J. Heinrich, D. Weiskopf, and S. Gumhold, “Visual Analysis of Trajectories in Multi-Dimensional State Spaces,” Computer Graphics Forum, vol. 33, iss. 6, pp. 310-321, 2014.
    [Bibtex]
    @article {Grottel2014HDTraj,
      author = {Grottel, Sebastian and Heinrich, Julian and Weiskopf, Daniel and Gumhold, Stefan},
      title = {{Visual Analysis of Trajectories in Multi-Dimensional State Spaces}},
      year = {2014},
      journal = {Computer Graphics Forum},
    volume = {33},
    number = {6},
    pages = {310--321},
      doi = {10.1111/cgf.12352}
    }

DOI: 10.1111/cgf.12352

This visualization was implemented as a plugin for the MegaMol visualization system. The source code can be downloaded freely and can be used according to the enclosed License:

hdtraj.mmplugin.ziphdtraj.mmplugin.zip Multi-Dimensional Trajectory Visualization MegaMol Plugin
[99.7 KB; MD5: 0a6eaf465318b0f256ecfdf8a8b4ad50; More Info]

To compile the MegaMol system and the plugin, use the appropriate Instructions on the MegaMol website.

Life is not easy as a multi-platform developer. This was the main reason for projects like VISlib and the now dead and buried TheLib. But times have changed. The new C++11 standard brought in some very nice and useful classes. Maybe the only thing I really miss right now is IPC, RPC and fundamentally sockets. However, the new threading classes are very nice, like, of course, std::thread.

Well, I am a Windows-software developer. And I continuously port my code to the other platforms, like Linux and sometimes OS X. Thus, there are always some issues when doing something for the first time. For example, when I tried to build my first test program for std::thread unter Ubuntu, I got the std::exception:

Operation not permitted

Well, of course, I linked against pthread. But something must have gone wrong. I asked the almighty Internet, and of course StackOverflow answered: http://stackoverflow.com/questions/9945391/stdthread-creation-throws-exception

In short words: It was an issue of the ordering of the arguments to Gcc, which in my opinion is one of the most annoying issues with the Gcc.

This does not work:

g++ -std=c++0x -lpthread -o test ./test.cpp

This does work:

g++ -std=c++0x -o test ./test.cpp -lpthread

User user405725 nicely summarized it in his comment:

You generally have to specify libraries AFTER object files or they are not pulled in.

Ok. So what about CMake: StackOverflow: http://stackoverflow.com/questions/1620918/cmake-and-libpthread

The different possibilities may also result in different parameter ordering. Following the formal way and using find_package:

cmake_minimum_required (VERSION 2.6)
find_package (Threads)
add_executable (myapp main.cpp ...)
target_link_libraries (myapp ${CMAKE_THREAD_LIBS_INIT})

everything works like it should be.

However, if I try to take the short way out, e.i. by specifying the arguments directly, like:

SET(CMAKE_CXX_FLAGS_DEBUG "... -lpthread")
SET(CMAKE_CXX_FLAGS_RELEASE "... -lpthread")

on my Ubuntu installation with my Gcc I ended up with the wrong ordering of arguments and my test program failed.

I like Cmake. I works. But you should not try to enforce your way of doing things if it is against the way of CMake used to do things. It will work up to some degree, but you will get problems going beyond that point. Just follow the way of CMake and, most of the time, everything will work.

I am back in Dresden. This was by far the most exhausting business travel ever. The Siggraph Asia 2014 was quite alright, but it completely filled up the days in the Chinese time zone. An the work for the German time zone in this week was as submission to the EuroVis 2015, the writing of a funding proposal, of a final project report, and the reading and commenting of a Ph.D. thesis of a friend of mine. There was few time left for sleeping and none at all for anything else. And that fun lasted the full seven days. My flights back to Germany were today, Sunday. From 4 am. Shenzhen time until now 8 pm. German time. And tomorrow morning I will be giving a lecture. I am so looking forward too that.