Hello Everyone. As many of you have probably noticed, Blinkdagger has not been posting with as much regularity. I would like to announce that this is probably going to be one of the last posts you will see at Blinkdagger. There are no plans to continue posting MATLAB tutorials in the immediate future.

At the time of this post, there are over 800 RSS subscribers, and over 2500 visitors a day on average. I started this website with Daniel from nothing and have developed it to an impressive level. A lot of you are probably wondering “Why?” I will do the best I can to explain the circumstances that have led to this decision.

Daniel Sutoyo Accepts a Position at The MathWorks

If there’s one good thing that has emerged from this website, it’s the fact that Daniel was able to obtain a position at The MathWorks. Unfortunately, as soon as Daniel became an employee of The MathWorks, there was a conflict of interest in being affiliated with this website. Originally, no one knew what to expect from this union. When we were going through the interview process, we were told that we would be able to maintain this blog while simultaneously working at The MathWorks. As it turns out, things would not be so simple.

After several meetings with The MathWorks legal team, it was determined that Daniel would be unable to contribute anything MATLAB related to this website. Thus, that essentially ended Daniel’s participation here at Blinkdagger as everything on this website is basically MATLAB related. Since this site took a great deal of effort to maintain, we found it difficult to continue on since one half of the team was removed from the equation. We had some big plans moving forward, but in the end we found that working around the legal ramifications would prove insurmountable, and that our time would be better spent on other projects.

The MathWorks Support - Or Lack of

One of the things that bothered me is that The MathWorks was not very supportive of the efforts over here at Blinkdagger. Over the course of this website’s life, the site provided over 100+ informative tutorials on how to use MATLAB to create GUIs, how to create plots, use particular functions, and various other tips and tricks on learning MATLAB.

I believe that Blinkdagger has created and maintained a valuable MATLAB resource; this is corroborated with hundreds if not thousands of positive feedback through the many comments that are received on a daily basis. Many months ago, I had queried The MathWorks on obtaining a personal license for MATLAB. Since this website provides many useful tutorials, it did not seem like a stretch by any means to make such a request. I was basically told that The MathWorks would be unable to provide such a license due to some legal restriction. If they were to provide such a license, they would then have to start monitoring the blog content, etc. To be honest, I found this quite frustrating. The way I saw it, it would be a win/win situation for both parties at hand. Unfortunately, the request was never granted.

Additionally, I felt that The MathWorks could have done a better job promoting and assisting websites like this one in order to cultivate an environment wherein more bloggers would be compelled to contribute to the MATLAB community. The MathWorks have created a great internal community at MATLAB central, but the potential for growth could be so much more and over a broader spectrum if they provided more support and incentive. In my opinion, it would be to the advantage of The MathWorks if there were more blogs like Blinkdagger out there, helping other users learn how to use this great tool. In fact, as of now, Blinkdagger is probably the largest external MATLAB website/blog. While The MathWorks have some internal blogs, those are homegrown and provide an entirely different flavor. The potential for external blogs is, in my opinion, much greater and provides a different platform wherein MATLAB can thrive and flourish.

Final Thanks

Finally, I would like to thank everyone who helped contribute to this site. Specifically, I would like to thank Rob Slazas, Sol Lederman, and Zane Montgomery, for their help throughout the last two years. Finally, I would like to thank everyone who was kind enough to leave an encouraging comment. The comments Blinkdagger received were the best part about maintaining this website, as it was concrete proof and positive reinforcement that Blinkdagger was helping others understand and use MATLAB. The reason Blinkdagger continued on for so long was because of the kind comments that were received.

In Closing

This blog has been something that I have poured a lot of work into, and it is difficult to leave it as is. If anyone is serious in contributing to the blog or wants to see Blinkdagger continue, please leave a comment below or send a memo through the contact form. For now, there will be no more tutorials, but the website will continue to be active until the end of the hosting contract (which may or may not be renewed).

The post is the sole property of blinkdagger.com. Please do no repost or distribute without consent.

The End of Blinkdagger? . . . . Possibly

How do global variables differ from regular (local) variables?

Each function in MATLAB contains a set of variables specific to that function.  Even in the same .m file, you don’t have (direct) access to variables created in other functions within the file.  Global variables give you the ability to create/change a variable in one function and have that updated variable accessible elsewhere.  This post will discuss two methods for handling (no pun intended) global variables, one of which is perfectly integrated into Graphical User Interfaces (GUIs).

METHOD 1: global VARIABLE

The first (non-GUI) way to create a global variable is to use the function ‘global’.  Create the global variables X, Y, and Z with the command:

global  X Y Z

The ‘global’ function needs to be called in each separate function (usually in the beginning) where the variables will be called.   Stylistically, the variable names are usually longer names and all in CAPS to indicate global variables within the functions.  The documented example in the MATLAB helps shows this pretty well:

function tic
global TICTOC %define/incorporate global variable at start of function
TICTOC = clock;

function t = toc
global TICTOC %accesses variable TICTOC (or creates it if TICTOC is undefined)
if nargout < 1
    elapsed_time = etime(clock, TICTOC)
else
    t = etime(clock, TICTOC);
end

Many hard-core coders prefer to avoid using ‘global’ except for constants.  The reason behind this is because it’s generally considered poor form to lock up a variable name (See Steve L’s comment below for another reason!).  While this won’t matter for smaller programs and functions, when the files get to be many hundreds (or thousands or millions) of lines long, it can be very difficult to keep track of all of the global variables and to remember to call all the necessary variables at the start of each function.  The great thing about GUIs is that they already have a built-in global structure to deal with all of your global variables: the handles.  The handles structure is an input (and therefore accessible) to every function in the GUI, making it perfectly capable doing everything the ‘global’ command can.  In fact, you shouldn’t ever have to use ‘global’ command when designing a GUI because the handles structure does the job so well.  GUIs and ‘global’ don’t mix kids!

METHOD 2: handles.variable

As you may have seen from many of the blinkdagger GUI tutorials, the handles structure is an extremely useful method to manipulate GUI boxes/buttons/tools.  But the tool data are all just stored variables that can be accessed anywhere within the GUI (aka global variables!).  Since we don’t need to edit any ‘property’ of the handles structure (e.g. handles.static_text, ‘String’), we don’t need to use the ‘get’/’set’ commands.  Creating the global variable is as easy as saying:

handles.x = 42;
%And of course, don't forget to update your handles structure:
guidata(hObject, handles);

handles.x is now an independent variable and note that it has no relation to the local variable x.

x = 43;

is a completely valid command in the same function that would not overwrite your global variable ‘handles.x’.

Remember, these variables can range from constants (e.g. 12) to strings (e.g. ‘Hello World’) to structures, cells, and arrays of constants/strings.

Hopefully you can see the usefullness of global variables and will use them (properly!) in your coding adventures.

The post is the sole property of blinkdagger.com. Please do no repost or distribute without consent.

MATLAB - Global Variables

Last time, we learned how to display data onto a table. This time, we’re going to learn how to work with table data within a GUI framework. For example, say you wanted to take the contents of the table manipulate the data. This tutorial will explain how to do that, and much more.

Contents

• Accessing Table Data within GUI Callbacks
• Accessing only the Selected Data
• Next Time
• Links and Downloads

Accessing Table Data within GUI Callbacks

Let’s say you have the following GUI:

For simplicity sake, let’s assume that you would like to create a button that will add 3 to each of the entries of the table when the button is pressed. How would you go about doing this? It’s actually quite straightforward. Let’s take a look at the callback for the add button:

function add_pushbutton_Callback(hObject, eventdata, handles)
% hObject    handle to add_pushbutton (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

%get the table data
tableData = get(handles.uitable1,'data');

%add 3 to the table
tableData = tableData + 3;

%update the table
set(handles.uitable1,'data',tableData);

So now, when I press the “Add 3″ button, it adds 3 to the table! This is just a simple example to show how to extract the data from the UITABLE, and to perform an operation on it.

Accessing only the Selected Data

Now, let’s up the difficulty level a bit. Let’s say you selected a couple of cells that you want to sum, as shown in the image below (You can hold onto the CTRL button while clicking on individual cells to select multiple cells).

How would you go about doing this? Read on and all will be revealed.

Enabling CellSelectionCallback

The first thing we need to do is to enable the Cell Selection Callback. But first, why are we doing this? Enabling this callback will allow us to keep track of what cells are being selected on the table. You can do this by bringing up the Property Inspector for the UITABLE, and then clicking the following icon as shown in the image below.

If you did it correctly, your m-file should have been updated to include the following:

% --- Executes when selected cell(s) is changed in uitable1.
function uitable1_CellSelectionCallback(hObject, eventdata, handles)
% hObject    handle to uitable1 (see GCBO)
% eventdata  structure with the following fields (see UITABLE)
%	Indices: row and column indices of the cell(s) currently selecteds
% handles    structure with handles and user data (see GUIDATA)

In addition, the CellSelectionCallback field should now be populated as shown in the image below:

Adding the Necessary Code

First, let’s create and initialize a variable to hold the table cell selection information. We will call this handles.selectedCells, and initialize it in the opening function.

% --- Executes just before uitable_tutorial_02 is made visible.
function uitable_tutorial_02_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% varargin   command line arguments to uitable_tutorial_02 (see VARARGIN)

%initialize this variable
handles.selectedCells = [];

Next, we go to the uitable1_CellSelectionCallback, which is the callback that we just enabled.

% --- Executes when selected cell(s) is changed in uitable1.
function uitable1_CellSelectionCallback(hObject, eventdata, handles)
% hObject    handle to uitable1 (see GCBO)
% eventdata  structure with the following fields (see UITABLE)
%	Indices: row and column indices of the cell(s) currently selecteds
% handles    structure with handles and user data (see GUIDATA)

%every time the cell selection changes, we update this data
%eventdata stores the indices of the selected cells
handles.selectedCells = eventdata.Indices;

%update the gui data
guidata(hObject, handles);

Adding the Selected Numbers Together

First, we’re going to add another button and a static text component to display the sum. The modified GUI looks like this:

Now, we need to write the callback for the button we just added:

% --- Executes on button press in sumNumbers_pushbutton.
function sumNumbers_pushbutton_Callback(hObject, eventdata, handles)
% hObject    handle to sumNumbers_pushbutton (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

%get the number of rows and columns
[rows,columns] = size(handles.selectedCells);

%get the data from the UITABLE
tableData = get(handles.uitable1,'data');

%initialize the sum
sum = 0;

%loop through each selected cell and keep a running sum
%can anyone thing of a better way to do this?
for x=1:rows
    sum = sum +tableData(tableIndices(x,1),tableIndices(x,2));
end

%display the sum on the GUI
set(handles.sum_text,'String',num2str(sum))

And there you have it, now you can select any number of cells, and then sum up the value of the contents!

Next Time

Next time, we’re going to talk about some of the cool features of the UITABLE that we have not yet discussed, including different data types within the UITABLE.

Links and Downloads

Download Source Files
The MathWorks Documentation for UITABLE
Cool Things You can do with UITABLE
Doug’s Video on UITABLE

The post is the sole property of blinkdagger.com. Please do no repost or distribute without consent.

MATLAB GUI Tutorial - UITABLE Part 2, How To Access Table Data

With the release of MATLAB 2008b, you are now able to add tables to a GUI. In the past, there was no easy way to display your data in tabular form. With the UITABLE component, displaying your data in tabular form is easy, and most importantly, looks great!

Contents

• Adding a Table to Your GUI using GUIDE
• Displaying Data on the Table
• Adding Column and Row Labels
• Modifying your Table through the m-file
• Next Time
• Links and Downloads

Adding a Table to Your GUI using GUIDE

Within the GUIDE framework, you can add a table to your GUI using the following icon from the toolbar: .

Here’s what the GUI will look like within GUIDE:

Displaying Data on the Table

We are going to populate the UITABLE component with data by pushing the “Populate Table” button. Thus, we’re going to need to add some code to the pushbutton’s callback. In the populate_pushbutton callback, we use the following code:

% --- Executes on button press in populate_pushbutton.
function populate_pushbutton_Callback(hObject, eventdata, handles)
% hObject    handle to populate_pushbutton (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

%first, create a data matrix that has 5 columns, 4 rows
myData = rand(5,4);

%now populate the table with the above values
set(handles.uitable1,'data',myData );

Now, let’s run the GUI and push the button!

A neat feature is that the table is smart enough to fill out the table according to the size of the data matrix that you feed it. So if I had done the following instead:

myData = rand(100,100);

The table would incorporate the use of scroll bars, as shown below.

Adding Column and Row Labels

A good way to spruce up your table is to add row and column labels. This helps differentiate your data and makes it easy to identify. Within the GUIDE framework, we can modify the labels by first bringing up the Property Inspector for the UITABLE. This can be done by double clicking the UITABLE component.

Now, if you click on any of the fields in the above picture, it will bring up the Table Property Editor. This is where you can add Row and Column labels. For example:

Make sure you click on the “Rows”, and that you select the “Show names entered below as the row headers” option. Finally, you just need to modify the names. Similarly, you can do the same for the columns.

Once you’re done with that. you should see the following:

And once you run your GUI, you can see the final result. A well labeled table that displays your data beautifully!

Modifying your Table through the m-file

Sometimes it’s easier to work from within the m-file framework, rather than the GUIDE framework. We could have done exactly what we did above programmatically through the m-file. In the opening function we could have done the following:

%store the row headers into a cell array
rowHeaders = {'Blink','Dagger','Loves','MATLAB','!!!!!!'};

%set the row labels
set(handles.uitable1,'RowName',rowHeaders);

%do the same for the column headers
columnHeaders = {'Quan','Daniel','Rob','Zane'};
set(handles.uitable1,'ColumnName',columnHeaders);

In this example, we assumed that we knew the dimensions of our table. If you don’t know the size of your table beforehand, then it can be difficult to apply data labels that are meaningful. By working through the m-file, you obtain more flexibility since you won’t have to go back and modify the .fig file every time you want to make a change. And if you are going to apply dynamic labeling, then working from the m-file is going to be much easier.

Next Time

Next time, we’re going to talk about how to work with manipulating the data within the table.

Links and Downloads

Download Source Files
The MathWorks Documentation for UITABLE
Cool Things You can do with UITABLE
Doug’s Video on UITABLE

The post is the sole property of blinkdagger.com. Please do no repost or distribute without consent.

MATLAB GUI Tutorial - UITABLE Part 1, How to Display Data

Besides the internal blogs over at The MathWorks website, there are a few hidden gems out there that don’t get as much recognition. One of these blogs is William Dwinnel’s MATLAB blog, Data Mining in MATLAB. We’ve actually been aware of Will’s site for quite some time now. In fact, he even wrote a guest post here at Blinkdagger a while back on the topic of combinatorics.

Why I Love to Data Mine

One of the things that I enjoy about Will’s blog is that he covers a wide variety of topics. One day you might see a post on Monte Carlo, and the next day you may see a post on parallel computing or conditional entropy. His simplistic style of writing makes for an easy read. Although he doesn’t update too frequently, it’s still a good blog to keep your eye on.

The post is the sole property of blinkdagger.com. Please do no repost or distribute without consent.

MATLAB - Data Mining in MATLAB