We will use Gimp to put these two photos together. We’ll open both photos as layers. You can click on File -> Open as Layers, or you can press Ctrl-Alt-O. On the layers palette, we’ll name the two layers “screen” and “room.”

Even though I used a tripod, my two photos don’t line up exactly, so I’ll need to correct that.

I put the screen layer above the room layer and set it to a low opacity. Then I used the move tool to get it lined up correctly.

Now I reset the opacity on the screen layer to 100% and move that layer below the room layer.

Right-click on the top layer and choose “Add layer mask.” In the box that pops up, choose to fill it with White (full opacity). On the layers palette, you’ll see a small white box next to the thumbnail of the top layer, and it will have a white border around it to indicate that it is the part of the layer you are now working with.

Here is some information about layer masks, from the Gimp documentation:

A transparency mask can be added to each layer, it’s called Layer mask. A layer mask has the same size and same pixel number as the layer to which it is attached. Every pixel of the mask can then be coupled with a pixel at the same location in the layer. The mask is a set of pixels in gray-tone on a value scale from 0 to 255. The pixels with a value 0 are black and give a full transparency to the coupled pixel in the layer. The pixels with a value 255 are white and give a full opacity to the coupled pixel in the layer.

Use the paths tool to draw around the edges of the screen. My tutorial on how to use the paths tool can be found here. Make sure you get the path right along the edge of the screen. It doesn’t hurt to get some outside the screen, but you want to make sure the blown out image is completely within the path you’re drawing. Then in the tool dialogue, click the “Selection from path” button.

Choose the paint bucket tool and make sure the foreground color is black. Click once inside the selection border. This fills the selection with black. But because we’re working on the layer mask, it simply makes everything on that layer, in that selection, invisible. So the image on the layer below now becomes visible through the “hole” we created in the layer mask above it.

Now we can flatten our image under the Image menu, and there we have our composite image with the correct exposure for both the TV screen and the areas around it.

http://en.wikipedia.org/wiki/File:Map_of_USA_with_state_names.svg

Then all I had to do was recolor it to fit my needs. I also added a color key and a title. Here is the end result:

The first thing we want to do is add the Composite transition to whatever clip we want to move around. Your clip could be a piece of video, or a picture, or a .png file with titles that you want to scroll across the screen. Drag the clip from the project tree to the timeline and then right-click on the clip. Click on Add Transition -> Composite.

A new thing should appear that looks kind of like a clip overlapping your clip. Click on it and drag the ends to match up with your clip. They should snap into place. Above the timeline on the left should be three tabs: Project Tree, Effect Stack, and Transition. If you’re not already on it, click on the Transition tab. The red rectangle in the dark area represents where on the screen your video appears. Right now it’s centered and covering the whole screen. Just below that is another timeline of sorts. On the left end of the timeline you should see a red triangle pointing down and a black triangle pointing up. The red triangle marks where a keyframe is. Kdenlive always puts a keyframe at the beginning of the clip for you.

To add another keyframe, drag the black triangle to the point on the timeline where you want to add it, and click the Add Keyframe button. It’s the fourth one from the left, just below the timeline.

So with keyframes, it basically tells Kdenlive where you want the video to be at a certain points. Kdenlive takes that information and moves the video between the two points over the course of the timeline between keyframes. For example, let’s say we wanted the video to move off the bottom right corner of the screen. We’ll just drag the red rectangle down and to the right while the black triangle is lined up with our keyframe. You’ll see in the project monitor on the right that the video has moved the same as the red triangle on the Transition tab. Also, Kdenlive draws a red line representing the path that the video will follow between the two keyframes.

Now we can add another keyframe farther along the timeline and move the video in a different direction. Just move the black arrow to the new point, click Add Keyframe, and drag the video to the new spot on the timeline. The video in the project monitor moves accordingly, and Kdenlive draws another red line showing where the video will move across the screen.

If you make a mistake while editing keyframes, don’t press Ctrl-Z, because Kdenlive will remove all the keyframe edits you have made since adding the composite transition. To get rid of a keyframe, you can move the black triangle to line up with the one you don’t want and click the Delete Keyframe button.

Now if you want to make titles scroll across the screen, all you have to do is create the titles using Inkscape. Make sure they have a transparent background and export them as a .png file in Inkscape. Import that file as a clip in Kdenlive. Right-click on it in the Project Tree and click on Clip Properties. Make sure the transparent background box is checked. Then drag the titles clip to the timeline. It should already have a Composite transition attached to it, but if it doesn’t, just add it with the method shown above. Drag the end of the clip to make it as long as you want it to be. On the transition tab, click the first button on the left below the timeline and resize the clip to its original size. Then position the red rectangle to where the top of the clip is below the screen. You can click on the first button below the timeline and align it to center horizontally. Move the black triangle to the end of the clip and add a new keyframe. Drag the red rectangle so the bottom is above the top of the screen. Align it to center horizontally again, so the titles will scroll straight up and down.

Welcome to the linux-minidisc Wiki, dedicated to collecting as much information as possible regarding NetMD/HiMD hardware in order to get it to work on Linux, MacOS X and *BSD.

The linux-minidisc project offers an open-source software package called QHiMDTransfer. It has an interface similar to SonicStage, without all the bloating that SonicStage has. Here is a screenshot:

Screenshot of QHiMDTransfer

It is still a work in progress, but it is exciting to see what Adrian Glaubitz and others have accomplished so far. There are several ways to get involved with the project. Just check out their list of tasks.

combos3.py

master = [] #create a list of combinations i've already tried in a previous program
for a in range (0, 6):
    for b in range (0, 6):
        for c in range (0, 6):
            for d in range (0, 6):
                combo = str(a+1) + str(b+1) + str(c+1) + str(d+1)
                if "1" in combo and "4" in combo:
                    master.append(combo) #add combinations with both a 1 and a 4 to the master list
possible = 0 #to keep track of the total number of possible combinations that meet the previously mentioned criteria
combo_two = "0000" #to set up a way to prevent counting "double doubles" twice
for a in range (0, 6):
    for b in range (0, 6):
        for c in range (0, 6):
	    for d in range (0, 6):
                combo = str(a+1) + str(b+1) + str(c+1) + str(d+1) #make a string from the values of whichever cycle all four loops are on
                if combo in master: #check to see if this combo has already been tried and added to the master list
                    break
                else:
                    for check in range (0, 3): #set up a loop to compare adjacent digits in combo
                        if combo_two != combo: #only performs the check if this combo hasn't already been counted
                            first = combo[check] #find one digit of combo to compare
                            second = combo[check+1] #find the following digit of combo to compare
                            if first == second:
                                print combo
                                combo_two = combo #this combo has been counted, so combo_two stops it from being checked again
                                possible = possible + 1
print "There are", possible, "possible combinations that have adjacent double digits, but do not contain both a 1 and a 4."

How it works

The first part of the program is very similar to our previous program, combos2.py. But instead of printing out those combinations, we’re adding them to a list called “master.” We first create the empty list with master = []. The brackets are what tell Python we want it to be a list. Then we go through our familiar loops for each digit in the combination. But instead of printing the combinations, we use master.append(combo). Append adds whatever is in the parentheses to our master list. Once it goes through all the loops, we move on to part 2 of the program.

Last time, we counted possible combinations with the variable x. This time, we’re going to be a little more descriptive and name the it “possible.” Being descriptive is another way to make your programs easier to read. We also make a string called combo_two, which we’ll use later to keep the program from counting the same combination more than once.

So we go through the loops again. Each time through, we check to see if combo is already in the master list. If it is, we tell Python to break that loop. Break will interrupt the smallest loop that the program is in at that particular moment. But if the combo we’re working on is not on the master list, then we can go on to the next instructions.

We make a for loop called “check.” Here is where combo_two comes into play. If it is not equal to combo (!= means not equal to), then we do the stuff on the next few lines. But if combo_two is equal to combo, i.e., not meeting the condition of the if statement, then Python skips over the next few lines and goes on back to do another cycle through the four loops that give us a new combo.

Strings

You can reference parts of strings by referring to them like this: Say the string called combo has “2452″ assigned to it. We can find the second character of that string by typing combo[1]. Remember, almost everything in Python begins with position 0, so position 1 is actually the second character in the string. So typing combo[1] would return the character “4.” Typing combo[0] would return “2,” combo[2] would return “5″ and combo[3] would return “2.”

Let’s assume we met the condition of the if statement, meaning that combo_two was not equal to combo. The “check” loop goes from 0 to 3. We’re going to use this loop to compare two adjacent characters in combo. We assign one character of combo to the string “first” by saying first = combo[check]. What’s in the brackets is the position of the string that we want to reference. On the first cycle through the check loop, check has a value of 0, so it’s like saying first = combo[0]. Then we assign the next character in combo to the string called “second” with second = combo[check+1]. So now the string “first” has the one character from the string “combo,” and the string “second” has the following character from combo.

The next line compares first to second. If they’re equal, we print out the combo and add one to the value of possible. Then we make combo_two equal to combo, so when Python goes back around to the next cycle of the check loop, it knows to not perform the checks on the same combo and produce duplicate results. But if the first and second string were not equal, then Python doesn’t print the combo, doesn’t assign combo_two the same value as combo, and repeats the check loop on the next two digits in combo.

So cycle 0 of the check loop compares the first and second digits of combo. Cycle 1 compares the second and third digits, and cycle 2 compares the third and fourth digits. Once it reaches cycle 3, the loop stops because the ending value of a loop is excluded.

Finally, once we have found all the combos that have double digits, but do not contain both a 1 and a 4, we tell Python to print a total to satisfy our curiosity.

combos2.py

x = 0
for a in range (0, 6):
    for b in range (0, 6):
        for c in range (0, 6):
            for d in range (0, 6):
                combo = str(a+1) + str(b+1) + str(c+1) + str(d+1)
                if "1" in combo and "4" in combo:
                    print combo
                    x = x + 1
print "There are", x, "combinations that contain both a 1 and a 4."

How it works

We start off by assigning the value 0 to the variable x, which will keep count of the number of combos with both a 1 and a 4 in them. We make four loops, a, b, c and d, to create all the different possible combinations. inside the fourth loop, we make a string called combo and put the string representations of the variables a, b, c and d in it. Then we look to see if the string combo has both “1″ and “4″ in it. If it does, we print combo and add 1 to the value of x. Once the program runs through all its loops, we have the program tell us how many combinations contain both a 1 and a 4. There are 302 of them. That’s a lot less than 1296, and it seems manageable.

Why the loops go from 0 to 6

When setting up a loop in Python, the number you want to start with is inclusive and the number you want to end with is exclusive. So with the first loop, a, it starts by assigning the value 0 to the variable a for that particular cycle of the loop, and then goes on to perform all the other instructions inside that loop. It continues to cycle through the loop until the value of the variable reaches 6. Once the value reaches 6, it does not go through the loop again. So the loop gets cycled through six times: 0, 1, 2, 3, 4 and 5. But the possible digits in the combination are 1 through 6, not 0 through 5, so when we are defining the string combo, we say it is str(a+1), etc., instead of str(a) to get a meaningful answer.

So why not just make the loop go from 1 to 7? We could do that, and it would work perfectly fine. But there is a reason I start with 0. Everything in lists and strings and other things in Python start with the value 0. For example, the string combo has four characters in it. Python refers to the position of each character as 0, 1, 2 and 3, not 1, 2, 3 and 4. So I usually make my loops start with 0 instead of 1, just so I keep myself in the mindset of everything beginning with 0 in Python. If I ever write anything more complicated with lots of variables and lists and strings and references to positions within strings and lists, it will help prevent confusion because I stay consistent with starting everything at 0.

Now, I have a list of 302 combinations I need to try to get my bike unlocked. I need to get busy.