


Vol 43, No 4 (2017)
- Year: 2017
- Articles: 8
- URL: https://journal-vniispk.ru/0361-7688/issue/view/10841
Article
An efficient mulithreading algorithm for the simulation of global illumination
Abstract
The calculation of global illumination taking into account not only the direct light but also all its possible reflections is an important part of the synthesis of realistic images. The simulation of global illumination requires a lot of computational resources. The performance of modern computers directly depends on the number of cores, which allow one to use tens of parallel computation threads. The paper is devoted to the effective use of multicore computers for simulating the global illumination. The computation results are represented in a uniform illumination map. The proposed algorithm dynamically creates additional threads for the critical branches of the computation process or processing of results. As a result, the uniform load of computation threads as achieved, and the physical and virtual cores are fully loaded.



Markov chain Monte Carlo based video tracking algorithm
Abstract
The paper considers a problem of multiple person tracking. We present the algorithm to automatic people tracking on surveillance videos recorded by static cameras. Proposed algorithm is an extension of approach based on tracking-by-detection of people heads and data association using Markov chain Monte Carlo (MCMC). Short track fragments (tracklets) are built by local tracking of people heads. Tracklet postprocessing and accurate results interpolation were shown to reduce number of false positives. We use position deviations of tracklets and revised entry/exit points factor to separate pedestrians from false positives. The paper presents a new method to estimate body position, that increases precision of tracker. Finally, we switched HOG-based detector to cascade one. Our evaluation shows proposed modifications significantly increase tracking quality.



Fast parallel grid warping-based image sharpening method
Abstract
The development of image sharpening algorithms is currently one of the most important problems in image processing. This paper presents a parallel implementation of a pixel grid warping algorithm for image sharpening. To sharpen image edges, the proposed algorithm moves pixels in the edge neighborhood towards edge centers rather than changing pixel values directly. This approach does not increase noise and does not cause ringing artifacts.



Environment modeling in a flight simulator
Abstract
An approach is proposed to the height and displacement maps normalization from the spectra described by J. Tessendorf. Techniques are considered to avoid some rendering artefacts with projected grids when the viewer is (1) far from the origin of a coordinate system and (2) near the waterline. Modeling and lighting of the water surface is described. Techniques based on volumetric models using screen-space raytracing for rendering various atmospheric effects (clouds, fog, rain, snow, etc.) are proposed. Approaches to implementing these techniques applicable to a wide range of real-time applications are described.



A method of Earth terrain tessellation on the GPU for space simulators
Abstract
This paper presents a new distributed method for virtual Earth terrain tessellation on a graphics processing unit (GPU) for space simulator complexes. The method operates in real time in multi-object virtual scenes comprising up to two million polygons. A polygonal terrain model is constructed using triangle patches of different levels of detail on graphics cards with programmable tessellation. Patches of the same level of detail are calculated entirely on the GPU, in parallel and independently, by using a developed shader program written in the OpenGL Shading Language (GLSL). This paper also describes a patch extraction algorithm for visible Earth surface rendering and an algorithm for correcting the barycentric coordinates of tessellated patch vertices that allows triangles in the terrain model to be docked without geometric discontinuities. Based on the distributed methods and algorithms developed, a program complex for virtual Earth surface visualization was created and successfully tested. The proposed solution can also be employed in virtual environment systems, virtual labs, educational geo-applications, etc.



An algorithm for the visualization of stereo images simultaneously captured with different exposures
Abstract
The visualization of stereo images obtained from two eyepiece cameras of a stereo microscope with different exposures is studied. This problem is solved to improve the quality of resulting images in the case when one image is not sufficient for capturing an object with the desired color reproduction accuracy and high level of detail both in dark and light regions. An approach to solving this problem in which differently exposed images are split between two views is considered. This approach allows us to significantly reduce the capturing time and to enhance the quality of capturing moving objects. The algorithm described in [1] is used as the basic algorithm; the main steps of this algorithm are the stereo matching of two input images and the construction of high dynamic range images. Modifications of the basic algorithm that use different stereo matching techniques are proposed. The application of the algorithm described in [2] for the visualization of stereo images without constructing high dynamic range images is discussed. A database of images captured with different exposures by a stereo microscope is created. The quality of algorithms applied to the images from this database is evaluated in the HDR-VDP-2.2 metric [3].



Interactive vizualization of constructive solid geometry scenes on graphic processors
Abstract
A ray-tracing algorithm for interactive visualization of very large and structurally complicated scenes presented in the constructive solid geometry (CSG) form is suggested. The algorithm is capable of visualizing such scenes in real time by using a graphic processor. As primitives, classical shapes and objects represented in an analytical form (in particular, second-order surfaces and implicit functions) are used. Unlike other similar algorithms, our algorithm produces the final image in a single pass and has no constraints on the maximum number of primitives and on the CSG tree depth. The key feature of the algorithm is a method for optimizing CSG models, which converts the input tree to an equivalent spatially coherent and well-balanced form (a completely balanced equivalent tree may not exist). The performance of visualization after applying the optimization technique is shown to depend on only the computational resource of the GPU (in contrast to multi-pass algorithms whose performance is restricted by memory capacity). It has been shown experimentally that our algorithm is capable of rendering CSG models consisting of more than a million CSG primitives with the tree depth up to 24.



SharpChecker: Static analysis tool for C# programs
Abstract
This paper considers various aspects of static analysis of C# programs in order to detect the maximum number of software bugs in an acceptable time. A complete cycle of software static analysis is described with the main focus being placed on the specifics of the C# language. Some methods are discussed that take into account popular features of C# at all levels of analysis: call graph and control flow graph construction, dataflow analysis, as well as context- and path-sensitive interprocedural analysis. A symbolic execution method is proposed, which is based on the works devoted to the Bounded Model Checking (BMC) and the Saturn Software Analysis Project. A memory model is described that enables an accurate intraprocedural analysis and allows one to create compact representations of error conditions associated with functions, which are essential for interprocedural analysis. A special attention is paid to the optimizations that occur during path-sensitive analysis of error conditions. The conditions need to be optimized in terms of size, because path-sensitive interprocedural analysis requires saving a large number of conditions for each analyzed function. The conditions are resolved using advanced SMT solvers (such as the Microsoft Z3 Prover). This paper also considers various approaches to modeling the behavior of library functions: based on a summary containing a set of properties required for analysis, or based on simplified implementations in C#. All the discussed solutions are implemented in the SharpChecker static analysis tool and are tested on a number of open-source projects from 1.5 thousand to 1.35 million lines of code.


