This website uses Google cookies to provide its services and analyze your traffic. Your IP address and user-agent are shared with Google, along with performance and security metrics, to ensure quality of service, generate usage statistics and detect and address abuses.More information

Search Options

ViewsSectionsTopics

UrlsCommentsAll

Search the site for the term 'C#'

This article closes the series on posture recognition using the Microsoft Kinect sensor. To finish, I will simply show you the implementation of a basic form that uses the class libraries explained in the previous articles.

We continue with the series about posture recognition with the Microsoft Kinect sensor. This time I will comment the classes responsible of posture normalization of the body in the way commented in the first article, so that we obtain a series of data that constitute a simplified version of the skeleton most appropriate for analysis using pattern recognition techniques.

In the previous article of this series I showed the structures, enumerations and classes that the application uses to be independent of the sensor version and the Kinect SDK. In this third article I will show a possible implementation of a class that deals with reading and converting the skeletons using version 2.0 of the SDK, for the Xbox One sensor.

In this second article in the series about recognition of postures using the Microsoft Kinect sensor I will show generic classes and structs used to isolate the application from the different versions of the SDK. The version of the SDK that we must use depends on the sensor model that we have. In the example code I have used version 2.0, for the Xbox One sensor.

One of the most interesting features offered by the Microsoft Kinect sensor is human bodies detection, which allows us to develop applications based on the different positions of the user's body and that can be handled remotely using those positions. To do this, it provides a series of points that represent the different joints of the body.

In previous articles I presented a home video surveillance system, the ThiefWatcher application. It is an extensible application that works combining several protocols, such as cameras, triggers, communication channels and storage systems. In this article I will show how to implement some of these protocols using the Microsoft Kinect sensor.

The Microsoft Kinect sensor is a very powerful device that provides image capturing, distance measurement and body postures and facial expressions recognition services, which makes it suitable for infinity of applications. In this introductory article I will show how to use it to capture different types of images.

Solving any Sudoku is a problem that can seem complicated if brute force methods are used, testing each and every one of the possible combinations. But, with the right approach, any of these problems can be solved in a few milliseconds. In this article, I will show you a way to achieve it through an optimized method.

To conclude this series about programming multitasking applications, I will show the use of a simple mechanism that allows implementing asynchronous methods whose waiting times are used for the execution of other parallel tasks or events triggered by user interface controls.

So far I have shown examples of multitasking that block the application until they finished. This is not very useful in practice. Usually, we want that the user can continue interacting with the application while the tasks are running in the background; we could want also the threads to interact with the user interface.

In multitasking applications there is a problem when concurrent access to resources, such as files or memory, when you launch several tasks at once. Two tasks cannot write at the same time in the same memory address, it is required to make sure that some data is not modified while we are reading them or things like that. In this article I will review the tools provided by .NET Framework to deal with these issues.

After reviewing the classes to implement the basic multitasking, in this article I will review different mechanisms that allow a synchronization between various tasks, all of them defined in the System.Threading namespace, with which you can organize the work when the Interactions between tasks require a particular order.

With this article begins a series in which I will review the basic mechanisms provided by the .NET Framework for the implementation of multitasking applications. First of all I will show the basic classes that allow you to launch multiple processes and make a performance comparison between them.

This is the last article of the series dedicated to the WinCA application. This application allows the edition and to execution of cellular automata. To finish, I will review the code that implements the automaton itself, using all the classes and interfaces explained in the previous articles.

I continue explaining the basics of the WinCA application code, dedicated to the designing and execution of cellular automata. This time I will tell you about the implementation of the cells and other auxiliary classes needed to build and execute automata.

We continue with the series dedicated to cellular automata and the WinCA application, dedicated to build and executing them. In this article I will explain the code related to the expression system that allows establishing the conditions to change from one state to another.

I continue to comment on the source code of the WinCA program, dedicated to cellular automata. In this article I will explain the interfaces and classes with which cell states are implemented and their edition. You can use these interfaces and classes as a basis to extend the application features.

Once reviewed the operation of the WinCA application, dedicated to cellular automata, let's see how the source code is organized. In this article I will explain the properties of cell states, and how they can be extended to add new functionalities by implementing new classes with the corresponding interfaces.

In this article, third of the series, I continue to explain the operation of the WinCA application, devoted to the construction and execution of cellular automata. This time I will show the language used to define the transitions between the different states of the automaton cells.

This is the second article in the series about the WinCA application, dedicated to the construction and execution of cellular automata. In this article I will show how to design the diferent states that can have the automaton cells, and the properties that can be assigned to them, using the application editors.