Apart from this, it also comes with some handy presentation features. You can view them as a slideshow, with your own comments. Equally, you can display multiple pictures as part of picture collage, as multi-exposure, or a picture pile of some description.

Its image editing, admittedly, is probably not as comprehensive as you will find in a commercial package. But, it is still good, with all the basic fixes like crop, straighten and contrast. Plus, effects are available with soft focus, sharpen and color saturation amongst numerous available.

If you are seeking greater image editing options, then Paint.Net is an alternative worth consideration. While it has the more traditional display, it has a greater number of special effects you can use to alter the photo. Particularly novel are its artistic effects, which can change your photo to resemble more of an oil painting, ink sketch or pencil sketch. Likewise, you can make numerous adjustments to such aspects as hue saturation, contrast etc. Color levels can also be tinkered with.

Aside from the photo editing features, Paint.Net also has paint and artistic features, which can allow for more artistic editing. You can paint, draw, or add shapes.

GIMP is not a package I have tried. However, it is stated that this is a free alternative to PhotoShop - one of the best commercial products. Such is the status of the freeware, that it has its own website.

It boasts features such as a customizable interface, photo enhancement, barrel distortion and digital retouching. All sounding very impressive, in addition to good hardware support and multiple platforms supported from Linux to Mac OS X. It also has documentation available on site.

The best thing about these 3 photo editing packages is indeed the freeware factor. They are not shareware limited to 30-day trial periods. Any limitation of one package is probably overcome by the other free alternatives, and collectively they surely must equal the value of a commercial product. So, browse, download and enjoy these freeware software, the best free photo editing has to offer.

1. GIMP

   It's a lot like Photoshop without the huge price tag. Free! Originally designed for Linux, it has been made for Windows as well. Works great for Vista where older Photoshop versions and other issues of compatibility don't exist!
   

2. Namo WebEditor

   So you want to create a website and may or may not know some html. Not a problem. Namo is structured similarly to Dreamweaver and again without the huge pricetag. This software runs $100 and comes with Namo FreeMotion and Namo FreeCanvas. I'm more impressed with FreeMotion as it's a flash based program and the instructions included make it easy enough for an amateur to use. Namo FreeCanvas isn't bad but I wouldn't pay anything extra for it. Worth checking out as part of the bundle. If you already own another web editor, there is typically a rebate for $20 off.
   

3. Pinnacle Studio

   Do you like editing video clips? If you do this program is reasonably priced and though not as fancy as Adobe's Premiere it's also much cheaper! Versions range from the original studio through Plus and Ultimate based on your needs. If you're editing standard video you can pay as little as $50. High Definition will cost you $100 and Studio Ultimate which allows for Dolby 5.1, fx editor, and a few other features be prepared to dish out $130. Typically Studio allows for an upgrade version and/or rebate based on your previous purchase.
   

4. Paint.net

   Again another photo editing software similar to Photoshop but easier to navigate for those that aren't advanced users. Free software again, can't complain there. The interface is easy and it doesn't lack features

1. First, create a new file of 400x400 pixels in the RGB mode
2. Take the Polygonal Lasso Tool and create a new shape, just like below
3. Make a new layer and fill the selection with this color coding, #404040
4. With the help of Polygonal Lasso Tool, again, create a new shape just like below
5. Make a new layer and fill the selection with this color coding, #D0D0D0
6. Again, with the help of Polygonal Lasso Tool, create another shape just like blow
7. Make a new layer and fill the selection with this color coding, #D0D0D0
8. And again, create another shape using Polygonal Lasso Tool, just like below
9. Make a new layer and fill the selection with this color coding, #D0D0D0
10. Open an image that you would like to put in your cube and put it above all other layers in the layers pallete
11. Now go to Edit > Free Transform. Using Ctrl key on your keyboard, you will be able to drag the individual corners so they are just outside the previous shape which will give it a nice clean edge.

Go to Blending Options and select the inner shadow and use the following settings:

1. Your image will look like this:
2. Repeat steps # 10, 11, and 12 to put your images to the other faces of the cube
3. And that's it your done! So, your final should look like this:

try { Robot screenshotRobot = new Robot(); BufferedImage screenshot = createScreenCapture(new Rectangle(x, y, width, height));} catch (Exception e) {}

Obviously in this case, "x" and "y" refer to the coordinates on the screen where the picture starts, and "width" and "height" refer to the width and height of the image to be taken. "screenShot" is where the image is stored and you can save or manipulate it from there. Both the Robot declaration and the screen capture have to be written inside of a "try" statement because either could fail and some operating systems don't allow them. That's pretty much all you need to know to take a picture of the screen with Java.

ScreenCapture Program

Using the above code, you could build a program to take a picture of the screen. Below, I've written a very simple sample program in Java that demonstrates how you could incorporate taking a screenshot into a program. This program takes a picture of the whole screen and the saves the image to a file called "Screenshot.png". Here's the code:

import java.awt.*;import java.awt.image.*;import java.awt.event.*;import javax.swing.*;import javax.imageio.*;import java.io.*; class ScreenCapture extends JFrame{ BufferedImage screenImage;
Dimension screenSize;
File savedImageFile;
Robot screenshotRobot;
JLabel statusLabel; public static void main(String args[]){
new ScreenCapture();
} ScreenCapture(){
setTitle("Java Screen Capturer");
setSize(300, 80);
savedImageFile = new File("Screenshot.png");
screenSize = Toolkit.getDefaultToolkit().getScreenSize();
try{
screenshotRobot = new Robot();
screenImage = screenshotRobot.createScreenCapture(new Rectangle(0, 0, screenSize.width, screenSize.height));
ImageIO.write(screenImage, "PNG", savedImageFile);
statusLabel=new JLabel("Screenshot was successfully taken and saved.");
}
catch(Exception e){
statusLabel=new JLabel("Error: " + e);
}
add(statusLabel);
setVisible(true); this.addWindowListener(
new WindowAdapter(){
public void windowClosing(WindowEvent we){
System.exit(0);
}
}
);
}
}

Understanding the Code

The above code may seem complex and somewhat scary, but the ideas are really quite simple and it doesn't take much to understand them. For those of you confused or interested in what a certain portion of code does, let's break it down.

import java.awt.*;import java.awt.image.*;import java.awt.event.*;import javax.swing.*;import javax.imageio.*;import java.io.*;

These are simply all the packages needed to run the program. "Java.awt" is the user interface toolkit. "Java.awt.image" let's us deal with images. "Java.awt.event" allows us to detect when the close button of the program or alt+f4 is pressed. "Javax.swing" allows us to use JFrames and Jlabels. "Javax.imageio" lets us write image files. And finally, "Java.io" allows us to deal with files.

class ScreenCapture extends JFrame{ ...}

This is the main program. All the code for the program goes in here.

BufferedImage screenImage;Dimension screenSize;File savedImageFile;Robot screenshotRobot;JLabel statusLabel;

Here's where we define the things we'll be using in our program. "screenImage" refers to the image we take of the screen. "screenSize" is where we store the dimensions of the screen. "savedImageFile" is the file in which the screenshot is saved. "screenshotRobot" is the Robot we use to take the screenshot. And lastly, "statusLabel" is what we use to display whether or not our program ran successfully.

public static void main(String args[]){
new ScreenCapture();
} This piece of code is our main method and it build the window. setTitle("Java Screen Capturer");
setSize(300, 80);
savedImageFile = new File("Screenshot.png");
screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Here we set the text in the title bar of the program to "Java Screen Capture" and set the size of the window to 300 by 80. After that we give the name of the file where the screenshot is to be saved. And finally, we get the dimensions of the screen.

try{ screenshotRobot = new Robot(); screenImage = screenshotRobot.createScreenCapture(new Rectangle(0, 0, screenSize.width, screenSize.height)); ImageIO.write(screenImage, "PNG", savedImageFile); statusLabel=new JLabel("Screenshot was successfully taken and saved.");}

Next, we attempt to create a Robot and then take a picture of the screen starting at the coordinates 0, 0 and extending across the entire screen. The third line of code in this section saves the image to a "PNG" file. And, if everything went okay, the text in the "statusLabel" is set to "Screenshot was successfully taken and saved."

catch(Exception e){ statusLabel=new JLabel("Error: " + e);}

If something went wrong in our program, the text in the "statusLabel" is set to "Error: " and it displays the problem.

add(statusLabel);
setVisible(true); Here, we add a label to the program which displays whether the program was able to run properly or not. Then using "setVisible(true)" we make our program show up on the screen. this.addWindowListener( new WindowAdapter(){ public void windowClosing(WindowEvent we){ System.exit(0); } });

This last section of code closes the program when either the close button of the program is pressed or the user closes the program some other way (i.e. alt+f4).

Other Uses for Taking a Screenshot

Taking a screenshot can be very useful for many things. For example, if you're making a drawing program, you could allow the user to take a picture of the screen and manipulate the image. You could also make your program take a picture of the screen when an error occurs so you have a better idea of how to fix the problem. I'm even currently developing a program that can beat certain computer games by itself by constantly taking pictures of the screen and scanning the colors. Whatever the use, taking a picture of the screen is incredibly simple and it's a great way to start programming in Java.

Hopefully you were able to get something out of this article and I apologize for it being so long. If there's anything I forgot to add, feel free to leave a message. Have fun coding in Java!

Here's a simple way to rescue those images from the recycle bin:

• Open the image in Photoshop (this may also work in PS Elements).
  
• Hit CTRL-J to duplicate the layer.
  
• On an image that is too bright, change the layer's blending mode to “multiply”.
  
• On an image that is too dark, change the blending mode to “screen”.
• Then adjust the layer's opacity with the slider at the top of the layers palette until you get the desired level of brightness.

You have to be careful using this, because just like over-adjusting the levels on the image will introduce noise, this method will accentuate noise or compression artifacts.

While this method does not give you the same control over an image as the adjustments available with RAW format, it can help you when you've got a JPG or TIFF that is just too dark or too light.

How can we get past this problem? One word, Double Buffering. Okay, so maybe that's two words. Even so, it's a very effective way of reducing, if not eliminating the screen flicker. When you double buffer in Java, Java creates a virtual image, draws all the components onto it, and then displays the image. That way, you only see the completed image, and animation looks smoother.

Double buffering can be accomplished by simply adding a couple things in your code. First you will need to make a new Image which will serve as the temporary image that you draw to. Then you need to get that image's graphics so that you can draw to the image. Finally, you would draw the completed image to the screen. This code, taken from the sample program below, demonstrates how you could do that.

public void paint(Graphics g){
 
Image bufferImage = createImage(this.getSize().width, this.getSize().height );
 
Graphics bufferGraphics = bufferImage.getGraphics();
 
bufferGraphics.setColor(new Color(255, 255, 255));
 
bufferGraphics.fillRect(0, 0, 300, 300);
 
bufferGraphics.setColor(new Color(0, 0, 0));
 
bufferGraphics.drawString(counter+"", 100, 100);
 
g.drawImage(bufferImage, 0, 0, this);
 
counter++;
 
repaint();
 
}

An explanation of the above code can be found further on in this article, when we take a look at a sample program that uses this technique. By now though, you may have all the information you need to fix the screen flicker. If not, or if you'd like to see the code in action, check out the next section.

The Double Bufferer

This is a simple program written to show how double buffering can be used in Java. It's only function is to display a constantly incrementing number which, in a way, is an animation. Note: The lines starting with “//” are comments and are not important to the code. They simply divide the code into smaller sections so that they can be explained easier.

import java.awt.*;
 
import java.awt.event.*;
 
import javax.swing.*;
 
class DoubleBufferer extends JFrame{
 
//Code Block 1
 
int counter;
 
public static void main(String args[]){
 
new DoubleBufferer();
 
}
 
DoubleBufferer(){

//Code Block 2

setTitle("Java Double Bufferer");
 
setSize(300, 300);
 
setVisible(true);

//Code Block 3

 

this.addWindowListener(
 
new WindowAdapter(){
 
public void windowClosing(WindowEvent we){
 
System.exit(0);
 
}
 
}
 
);

}

//Code Block 4

public void paint(Graphics g){
 
Image bufferImage = createImage(this.getSize().width, this.getSize().height );
 
Graphics bufferGraphics = bufferImage.getGraphics();
 
bufferGraphics.setColor(new Color(255, 255, 255));
 
bufferGraphics.fillRect(0, 0, 300, 300);
 
bufferGraphics.setColor(new Color(0, 0, 0));
 
bufferGraphics.drawString(counter+"", 100, 100);
 
g.drawImage(bufferImage, 0, 0, this);
 
counter++;
 
repaint();
 
}

}

Here's a brief explanation of that segment of code:

Code Block 1:

This is simply where we declare the integer “counter”, which is the variable we increment to show animation.

Code Block 2:

We use “setTitle()” to set the text in the in the title bar to “Java Double Bufferer”. “setSize(300, 300)” changes the size of the window to 300 by 300 pixels. Finally, “setVisible(true)”, as the name suggests, makes the program's window visible on the screen.

Code Block 3:

This section of code terminates the program if the user closes it via the close button on the top right, pressing alt+f4, or some other means.

Code Block 4:

This is the main part of our program. Here, we create an image called “bufferImage” with the width and height being the size of the program's window. “this.getSize()” simply returns both the width (using getSize().width) and height (using getSize().height) of the program's window. Next, you create a new graphics object called “bufferGraphics” and get the graphics from the “bufferedImage” using “getGraphics()”.

We set the drawing color to white with “setColor(new Color(255, 255, 255))”, and then we draw a rectangle the size of the program's window using “fillRect()”. Then we change the color to black with “setColor(new Color(0, 0, 0))”, and use “drawString()” to draw the value of “counter“. The reason we have to write “drawString(counter+””)” is because “drawString()” only draws strings. “counter” is an integer and Java will throw an error if we try to draw it. Adding a string to counter (done by adding “”) makes Java display it as a string.

Finally, after everything's been drawn to our temporary image “bufferedImage”, we can display the whole thing at once, completely removing the flicker, using “drawImage()”.

Once that's all done, the only thing left to do is increment “counter”, which is done by “counter++”, and then call “repaint()”, which will repaint everything and start the process over.

Practical Uses for Double Buffering

As mentioned at the outset, double buffering is very effective in removing the screen flicker that occurs when the screen is rapidly redrawn. Games, movies, animations, and other programs that require frequent screen refreshing often benefit by using this method.

With any luck, you should feel more confident when it comes to double buffering. Thanks for checking out this article, and if you've got any suggestions, don't hesitate to leave a comment.

• Archive format:7z
• Compression level: Ultra
• Compression Method:LZMA
• Dictionary size: 64MB
• Word Size:64.

Once done you can delete those files you were trying to hide because they are now in the .7z file you just made. Open command prompt by going to start run and put in cmd. to make it easier make a folder on your desktop and put the .7z file and the .jpg file in the folder so its all in one place.

Lets call the folder its in x123 the .7z file shadow.7z and the .jpg return.jpg. So now in command prompt it should say c:/ documents and settings> "your pc's name">. Now next to that put cd x123 so it opens the folder it should now be c:/ documents and settings>"Your pc's name">x123>. After that put in COPY /B return.jpg + shadow.7z returnsecret.jpg after this it should say 1 file copied and there should be a new .jpg file in your x123 folder called returnsecret.jpg.

To get the files off of the new image file lets say you had passwords there and you need to get them back open 7-zip again and select returnsecret.jpg now press the extract button. There should now be a folder called returnsecret with the files you just hide inside the image. You can delete this folder and extract it again from the image over and over. Hide it in a thumbdrive,psp,external drive, iPod, or any mass media and only you will know that the files are there or even how to extract them.

If you see a picture you like online, right click it and select copy image (Firefox), or hold the mouse down on the picture until a menu appears and select copy image (Mac Internet Explorer).

If you want to copy simply what you're looking at on the computer, whether it be offline or online, press "Print Screen" on your keyboard or if you want to copy a certain program's image off separately, press "Alt-Print Screen" together. If you want to copy text, the short key is "Ctrl+C" pressed together, that is, after you've highlighted the text you want to copy.

Hope this helped!

Why it's worth to use CD/DVD emulators?

• From an “image”, all data is faster than from a CD or DVD.
• You can download “images” from internet and share them with others.
• No sound from your CD/DVD-ROM.
• You can use few “images” at a time.
• Programs, movies and games works faster, than from discs.
• Emulator is free or very cheap.
• If you have a notebook, you will save battery power.

Where you can find “images”?

You can always find “images” on P2P. You can also download from FTP or find using google.com. “Images” can be various, but a good emulator, has to support them all. Often “images” are .bin, .cue, .img, .nrg, .mdf, .mds, .ccd. Another important thing is that “images” can be 700mb and more. Download can take a while.

Installing “Daemon Tools”

One of the most popular emulators is “Daemon Tools”. This emulator is free and easy to use. It can open up to four “images” at a time.

Go to Daemon Tools. Find and press DOWNLOADS. Now find “DEAMON Tools” and press it. After that press on DAEMON TOOLS *.** X86. (* is version nr.). Now you can download this emulator.

When download is finished, install “Daemon-Tools”. After that, restart your computer.

Opening CD/DVD “image”

On the right corner of your screen press “Daemon-Tools” picture. Select DEVICE 0: [F:] NO MEDIA. Now find your “image” and open it. Emulator will open “image”.

Why “image” isn't working?

Sometimes discs are protected from copying. “Daemon-Tools” can simulate an original disc. To do that, press “Daemon-Tools” on the right corner of the screen with right mouse button. Select EMULATION and press ALL OPTIONS ON. If you done everything right, “Daemon-Tools” picture will become green.

Why my DVD movie doesn't work?

Our world is divided into six regions. Each region has a special code. If you want to watch a movie of other region, you will have to change it. Press the right button on “Daemon-Tools” and select VIRTUAL CD/DVD-ROM. After that press on DEVICE 0: [F:] and select SET DEVICE PARAMETERS. Find DVD REGION and select, which you need. You can find a picture of all regions at mvps.org.

First check your taskbar near your clock for this image,

If you see this image but its red do not worry, if you don’t see the image go start > all programs > daemon tools > daemon this will load the software and show the icon wither green or red in your taskbar.

Right once you have the software loaded in your taskbar right clock on the image a go virtual cd/dvd rom drive look at the image below,

The select device 0 [f] no media, this should open another menu like so

Click mount image, in the pop box that appears find your image of the game, and click open, this will mount the image in to daemon tools ready for use, and that’s all there is to it, hope this helped.