Jenil Pratheesh & Aalifha Wedding invitation

My dear friend, I would be grateful to have your presence near me on the most important and responsible day of my life – the day when I get married to my beloved man/woman. I anticipate seeing you, hearing your words of wisdom, and getting a tight hug before I start my new life with the person I love.

Dear brother/sister, I want to express my wish to see you on my special wedding day, and this is why I am sending you this message. I look forward to seeing you on the day I tie the knot because the ceremony will be a little less complete without you. I love you! 

There are moments in life which hold a lot of importance. For me, the wedding is the most important holiday. So, I want to invite you, my close friend, to attend my and my partner’s special day.

My dearest friends! I could not forget about you on my wedding day. I sincerely hope that you will give me an honor of attending my wedding.

It made me so happy to see you there at my party. I had a wonderful time. I hope you had a wonderful time as well!

Wedding Invitation Jesi & Anand

Welcome To All

CP7211 Advanced Databases Lab

CP7211 Advanced Databases Lab Manual Download link.......

CP7211 Advanced Databases Lab

CP7212 CASE STUDY – OPERATING SYSTEMS DESIGN Lab Manual

 OPERATING SYSTEMS DESIGN Lab Manual down load and use this

CP7212 CASESTUDY – OPERATING SYSTEMS DESIGN 

Longest Common Subseequence Problem Codings in java

import java.io.*;

public class LCS {


  public static void main(String [] args) throws IOException {

    System.out.println("LCS = "+lcsrec("BABCDAB","ABDACB"));
    System.out.println("LCS = "+lcsrec2("TATTACC","GTTCAATA"));
    System.out.println("LCS = "+lcsdyn("GTATATATATACC","GTTCCTAATA"));
  }


  // Precondition: Both x and y are non-empty strings.
  public static int lcsrec(String x, String y) {

    // If one of the strings has one character, search for that character
    // in the other string and return the appropriate answer.
    if (x.length() == 1)
      return find(x.charAt(0), y);
    if (y.length() == 1)
      return find(y.charAt(0), x);
     
    // Solve the problem recursively.

    // Corresponding beginning characters match.
    if (x.charAt(0) == y.charAt(0))
      return 1+lcsrec(x.substring(1), y.substring(1));

    // Corresponding characters do not match.
    else
      return max(lcsrec(x,y.substring(1)), lcsrec(x.substring(1),y));

  }

  // Note: This second recursive version, though more cumbersome in code
  //       because of how the substring method works more accurately
  //       mirrors the algorithms used in the dynamic programming method
  //       below, since this uses LCS's of prefixes to compute LCS's
  //       of longer strings.
  // Precondition: Both x and y are non-empty strings.
  public static int lcsrec2(String x, String y) {

    // If one of the strings has one character, search for that character
    // in the other string and return the appropriate answer.
    if (x.length() == 1)
      return find(x.charAt(0), y);
    if (y.length() == 1)
      return find(y.charAt(0), x);
     
    // Solve the problem recursively.

    // Corresponding last characters match.
    if (x.charAt(x.length()-1) == y.charAt(y.length()-1))
      return 1+lcsrec2(x.substring(0,x.length()-1),
               y.substring(0,y.length()-1));

    // Corresponding last characters do not match.
    else
      return max(lcsrec2(x,y.substring(0,y.length()-1)),
         lcsrec2(x.substring(0,x.length()-1),y));

  }

  // Precondition: Both x and y are non-empty strings.
  public static int lcsdyn(String x, String y) {

    int i,j;
    int lenx = x.length();
    int leny = y.length();
    int[][] table = new int[lenx+1][leny+1];

    // Initialize table that will store LCS's of all prefix strings.
    // This initialization is for all empty string cases.
    for (i=0; i<=lenx; i++)
      table[i][0] = 0;
    for (i=0; i<=leny; i++)
      table[0][i] = 0;
   
    // Fill in each LCS value in order from top row to bottom row,
    // moving left to right.
    for (i = 1; i<=lenx; i++) {
      for (j = 1; j<=leny; j++) {

        // If last characters of prefixes match, add one to former value.
        if (x.charAt(i-1) == y.charAt(j-1))
          table[i][j] = 1+table[i-1][j-1];

        // Otherwise, take the maximum of the two adjacent cases.
        else
          table[i][j] = max(table[i][j-1], table[i-1][j]);
      }
    }
    return table[lenx][leny];
  }

  // Returns 1 if c is contained in x, and 0 otherwise.
  public static int find(char c, String x) {
   
    for (int i=0; i<x.length(); i++)
      if (c == x.charAt(i))
        return 1;

    return 0;
  }

  // Returns the greater of x and y.
  public static int max(int x, int y) {
    if (x > y)
      return x;
    else
      return y;
  }
}

Java program for Throwing Dies in Randomized Counting

import java.util.Random;

public class Dice1 {

    public static void main(String[] args) {
        Random rand = new Random();
        int min = 1;
        int max = 6;
        int loop = 0;
        int diceRollOne = 0;
        int diceRollTwo = 0;
        int diceTotal = 0;
        int prevDiceTotal = 0;

        while (loop < 2) {
            loop++;
            diceRollOne = rand.nextInt(max - min + 1) + min;
            diceRollTwo = rand.nextInt(max - min + 1) + min;
            diceTotal = diceRollOne + diceRollTwo;

            System.out.println("Dice Roll 1: " + diceRollOne);
            System.out.println("Dice Roll 2: " + diceRollTwo);
            System.out.println("Dice Total: " + diceTotal);
            System.out.println("previous total: " + prevDiceTotal);

           

            if (diceRollOne == diceRollTwo || diceTotal == prevDiceTotal) {
                System.out.println("After " + loop + " loops the");
                System.out.println("Numbers Match, YOU WIN, GOOD DAY SIR!");
        System.exit(0);
                }
             else  
               {
                System.out.println("Numbers Match, YOU GET NOTHING, YOU LOSE, GOOD DAY SIR!");

}
prevDiceTotal = diceTotal;
}           

    }
}

Random counding number programe in java

import java.util.Random;
public class QuickRandom {
    public static void main(String[] args) {
      System.out.println("The following is a list of 100 random" +
              " 3 digit numbers.");
      Random rand= new Random();
     
     
      for(int i=0;i<100;i++)
      {     
          int pick = rand.nextInt(900) + 100;
          System.out.println(pick);
         
          int sum = 0;
         
          sum += pick + pick;
         
          System.out.println("The sum is: " + sum + ".");
        }
  
    }
   
}
   
   

Defintion of Project scope

Project scope is the part of project planning that involves determining and documenting a list of specific project goals, deliverables, tasks, costs and deadlines.
The documentation of a project's scope, which is called a scope statement, terms of reference or statement of work, explains the boundaries of the project, establishes responsibilities for each team member and sets up procedures for how completed work will be verified and approved. During the project, this documentation helps the project team remain focused and on task. The scope statement also provides the project team with guidelines for making decisions about change requests during the project.
It is natural for parts of a large project to change along the way, so the better the project has been "scoped" at the beginning, the better the project team will be able to manage change. When documenting a project's scope, stakeholders should be as specific as possible in order to avoid scope creep, a situation in which one or more parts of a project ends up requiring more work, time or effort because of poor planning or miscommunication.
Effective scope management requires good communication to ensure that everyone on the team understands the scope of the project and agrees upon exactly how the project's goals will be met. As part of project scope management, the team leader should solicit approvals and sign-offs from the various stakeholders as the project proceeds, ensuring that the finished project, as proposed, meets everyone's needs.

Go To Get The Goal

This Image is taken on the day of  Network engineering Seminar in RIIT Kanyakumari.

Dijkstra Program in JAVA

import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class dijkstra
{
    private int distances[];
    private Set<Integer> settled;
    private Set<Integer> unsettled;
    private int number_of_nodes;
    private int adjacencyMatrix[][];

    public dijkstra(int number_of_nodes)
    {
        this.number_of_nodes = number_of_nodes;
        distances = new int[number_of_nodes + 1];
        settled = new HashSet<Integer>();
        unsettled = new HashSet<Integer>();
        adjacencyMatrix = new int[number_of_nodes + 1][number_of_nodes + 1];
    }

    public void dijkstra_algorithm(int adjacency_matrix[][], int source)
    {
        int evaluationNode;
        for (int i = 1; i <= number_of_nodes; i++)
            for (int j = 1; j <= number_of_nodes; j++)
                adjacencyMatrix[i][j] = adjacency_matrix[i][j];

        for (int i = 1; i <= number_of_nodes; i++)
        {
            distances[i] = Integer.MAX_VALUE;
        }

        unsettled.add(source);
        distances[source] = 0;
        while (!unsettled.isEmpty())
        {
            evaluationNode = getNodeWithMinimumDistanceFromUnsettled();
            unsettled.remove(evaluationNode);
            settled.add(evaluationNode);
            evaluateNeighbours(evaluationNode);
        }
    }

    private int getNodeWithMinimumDistanceFromUnsettled()
    {
        int min ;
        int node = 0;

        Iterator<Integer> iterator = unsettled.iterator();
        node = iterator.next();
        min = distances[node];
        for (int i = 1; i <= distances.length; i++)
        {
            if (unsettled.contains(i))
            {
                if (distances[i] <= min)
                {
                    min = distances[i];
                    node = i;
                }
            }
        }
        return node;
    }

    private void evaluateNeighbours(int evaluationNode)
    {
        int edgeDistance = -1;
        int newDistance = -1;

        for (int destinationNode = 1; destinationNode <= number_of_nodes; destinationNode++)
        {
            if (!settled.contains(destinationNode))
            {
                if (adjacencyMatrix[evaluationNode][destinationNode] != Integer.MAX_VALUE)
                {
                    edgeDistance = adjacencyMatrix[evaluationNode][destinationNode];
                    newDistance = distances[evaluationNode] + edgeDistance;
                    if (newDistance < distances[destinationNode])
                    {
                        distances[destinationNode] = newDistance;
                    }
                    unsettled.add(destinationNode);
                }
            }
        }
    }

    public static void main(String... arg)
    {
        int adjacency_matrix[][];
        int number_of_vertices;
        int source = 0;
        Scanner scan = new Scanner(System.in);
        try
        {
            System.out.println("Enter the number of vertices");
            number_of_vertices = scan.nextInt();
            adjacency_matrix = new int[number_of_vertices + 1][number_of_vertices + 1];

            System.out.println("Enter the Weighted Matrix for the graph");
            for (int i = 1; i <= number_of_vertices; i++)
            {
                for (int j = 1; j <= number_of_vertices; j++)
                {
                    adjacency_matrix[i][j] = scan.nextInt();
                    if (i == j)
                    {
                        adjacency_matrix[i][j] = 0;
                        continue;
                    }
                    if (adjacency_matrix[i][j] == 0)
                    {
                        adjacency_matrix[i][j] =  Integer.MAX_VALUE;
                    }
                }
            }

            System.out.println("Enter the source ");
            source = scan.nextInt();

            dijkstra dijkstrasAlgorithm = new dijkstra(number_of_vertices);
            dijkstrasAlgorithm.dijkstra_algorithm(adjacency_matrix, source);

            System.out.println("The Shorted Path to all nodes are ");
            for (int i = 1; i <= dijkstrasAlgorithm.distances.length - 1; i++)
            {
                System.out.println(source + " to " + i + " is "+ dijkstrasAlgorithm.distances[i]);
            }
        }
        catch (InputMismatchException inputMismatch)
        {
            System.out.println("Wrong Input Format");
        }
        scan.close();
    }
}

Recursive DFS

import java.io.*;
class dfs
{
static void dfs(int a[][], int m[], int i, int n)
{
int j;
 m[i] = 1;
System.out.println("\t" + (i+1));
for(j=0; j<n; j++)  
    if(a[i][j]==1 && m[j]==0)      
        dfs(a,m,j,n);
}
public static void main(String args[]) throws IOException
{
int  n, i, j;
System.out.println("No. of vertices : ");
BufferedReader br= new BufferedReader (new InputStreamReader(System.in));
n =Integer.parseInt(br.readLine());
int m[]= new int[n];
int a[][] = new int[n][n];
for (i=0; i<n; i++)
{
    m[i] = 0;
}
System.out.println("\n\nEnter 1 if edge is present, 0 if not");
for (i=0; i<n; i++)
{
    System.out.println("\n");
    for (j=i; j<n; j++)
    {
        System.out.println("Edge between " + (i+1) + " and " +  (j+1)+ " : ");
        a[i][j] =Integer.parseInt(br.readLine());
        a[j][i]=a[i][j];
    }
    a[i][i] = 0;
}
System.out.println("\nOrder of accessed nodes : \n");
for (i=0; i<n; i++)
    if (m[i]==0)
        dfs(a,m,i,n);


}
}

Recursive DFS in JAVA

import java.io.*;

class dfs

{

static void dfs(int a[][], int m[], int i, int n)

{

int j;

 m[i] = 1;

System.out.println("\t" + (i+1));

for(j=0; j<n; j++)   

    if(a[i][j]==1 && m[j]==0)        

        dfs(a,m,j,n);

}  

public static void main(String args[]) throws IOException

{

int  n, i, j;

System.out.println("No. of vertices : ");

BufferedReader br= new BufferedReader (new InputStreamReader(System.in));

n =Integer.parseInt(br.readLine());

int m[]= new int[n];

int a[][] = new int[n][n];

for (i=0; i<n; i++)

{

    m[i] = 0;

}

System.out.println("\n\nEnter 1 if edge is present, 0 if not");

for (i=0; i<n; i++)

{

    System.out.println("\n");

    for (j=i; j<n; j++)

    {

        System.out.println("Edge between " + (i+1) + " and " +  (j+1)+ " : ");

        a[i][j] =Integer.parseInt(br.readLine());

        a[j][i]=a[i][j];

    }

    a[i][i] = 0;

}

System.out.println("\nOrder of accessed nodes : \n");

for (i=0; i<n; i++)

    if (m[i]==0)

        dfs(a,m,i,n);

}

} 

Dijkstra program in JAVA

import java.util.HashSet;

import java.util.InputMismatchException;

import java.util.Iterator;

import java.util.Scanner;

import java.util.Set;

 

public class dijkstra

{

    private int distances[];

    private Set<Integer> settled;

    private Set<Integer> unsettled;

    private int number_of_nodes;

    private int adjacencyMatrix[][];

 

    public dijkstra(int number_of_nodes)

    {

        this.number_of_nodes = number_of_nodes;

        distances = new int[number_of_nodes + 1];

        settled = new HashSet<Integer>();

        unsettled = new HashSet<Integer>();

        adjacencyMatrix = new int[number_of_nodes + 1][number_of_nodes + 1];

    }

 

    public void dijkstra_algorithm(int adjacency_matrix[][], int source)

    {

        int evaluationNode;

        for (int i = 1; i <= number_of_nodes; i++)

            for (int j = 1; j <= number_of_nodes; j++)

                adjacencyMatrix[i][j] = adjacency_matrix[i][j];

 

        for (int i = 1; i <= number_of_nodes; i++)

        {

            distances[i] = Integer.MAX_VALUE;

        }

 

        unsettled.add(source);

        distances[source] = 0;

        while (!unsettled.isEmpty())

        {

            evaluationNode = getNodeWithMinimumDistanceFromUnsettled();

            unsettled.remove(evaluationNode);

            settled.add(evaluationNode);

            evaluateNeighbours(evaluationNode);

        } 

    }

 

    private int getNodeWithMinimumDistanceFromUnsettled()

    {

        int min ;

        int node = 0;

 

        Iterator<Integer> iterator = unsettled.iterator();

        node = iterator.next();

        min = distances[node];

        for (int i = 1; i <= distances.length; i++)

        {

            if (unsettled.contains(i))

            {

                if (distances[i] <= min)

                {

                    min = distances[i];

                    node = i;

                }

            }

        }

        return node;

    }

 

    private void evaluateNeighbours(int evaluationNode)

    {

        int edgeDistance = -1;

        int newDistance = -1;

 

        for (int destinationNode = 1; destinationNode <= number_of_nodes; destinationNode++)

        {

            if (!settled.contains(destinationNode))

            {

                if (adjacencyMatrix[evaluationNode][destinationNode] != Integer.MAX_VALUE)

                {

                    edgeDistance = adjacencyMatrix[evaluationNode][destinationNode];

                    newDistance = distances[evaluationNode] + edgeDistance;

                    if (newDistance < distances[destinationNode])

                    {

                        distances[destinationNode] = newDistance;

                    }

                    unsettled.add(destinationNode);

                }

            }

        }

    }

 

    public static void main(String... arg)

    {

        int adjacency_matrix[][];

        int number_of_vertices;

        int source = 0;

        Scanner scan = new Scanner(System.in);

        try

        {

            System.out.println("Enter the number of vertices");

            number_of_vertices = scan.nextInt();

            adjacency_matrix = new int[number_of_vertices + 1][number_of_vertices + 1];

 

            System.out.println("Enter the Weighted Matrix for the graph");

            for (int i = 1; i <= number_of_vertices; i++)

            {

                for (int j = 1; j <= number_of_vertices; j++)

                {

                    adjacency_matrix[i][j] = scan.nextInt();

                    if (i == j)

                    {

                        adjacency_matrix[i][j] = 0;

                        continue;

                    }

                    if (adjacency_matrix[i][j] == 0)

                    {

                        adjacency_matrix[i][j] =  Integer.MAX_VALUE;

                    }

                } 

            } 

 

            System.out.println("Enter the source ");

            source = scan.nextInt();

 

            dijkstra dijkstrasAlgorithm = new dijkstra(number_of_vertices);

            dijkstrasAlgorithm.dijkstra_algorithm(adjacency_matrix, source);

 

            System.out.println("The Shorted Path to all nodes are ");

            for (int i = 1; i <= dijkstrasAlgorithm.distances.length - 1; i++)

            {

                System.out.println(source + " to " + i + " is "+ dijkstrasAlgorithm.distances[i]);

            }

        } 

        catch (InputMismatchException inputMismatch)

        {

            System.out.println("Wrong Input Format");

        }

        scan.close();

    }

}

Network flow Program in JAVA

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;

public class NetworkFlowProb
{                              
    private int[] parent;
    private Queue<Integer> queue;
    private int numberOfVertices;
    private boolean[] visited;
    private Set<Pair> cutSet;
    private ArrayList<Integer> reachable;
    private ArrayList<Integer> unreachable;

    public NetworkFlowProb (int numberOfVertices)
    {
        this.numberOfVertices = numberOfVertices;
        this.queue = new LinkedList<Integer>();
        parent = new int[numberOfVertices + 1];
        visited = new boolean[numberOfVertices + 1];
        cutSet = new HashSet<Pair>();
        reachable = new ArrayList<Integer>();
        unreachable = new ArrayList<Integer>();
    }

    public boolean bfs (int source, int goal, int graph[][])
    {
        boolean pathFound = false;
        int destination, element;
        for (int vertex = 1; vertex <= numberOfVertices; vertex++)
        {
            parent[vertex] = -1;
            visited[vertex] = false;
        }
        queue.add(source);
        parent[source] = -1;
        visited[source] = true;

        while (!queue.isEmpty())
        {
            element = queue.remove();
            destination = 1;
            while (destination <= numberOfVertices)
            {
                if (graph[element][destination] > 0 &&  !visited[destination])
                {
                    parent[destination] = element;
                    queue.add(destination);
                    visited[destination] = true;
                }
                destination++;
            }
        }

        if (visited[goal])
        {
            pathFound = true;
        }
        return pathFound;
    }

    public int  networkFlow (int graph[][], int source, int destination)
    {
        int u, v;
        int maxFlow = 0;
        int pathFlow;
        int[][] residualGraph = new int[numberOfVertices + 1][numberOfVertices + 1];

        for (int sourceVertex = 1; sourceVertex <= numberOfVertices; sourceVertex++)
        {
            for (int destinationVertex = 1; destinationVertex <= numberOfVertices; destinationVertex++)
            {
                residualGraph[sourceVertex][destinationVertex] = graph[sourceVertex][destinationVertex];
            }
        }

        /*max flow*/
        while (bfs(source, destination, residualGraph))
        {
            pathFlow = Integer.MAX_VALUE;
            for (v = destination; v != source; v = parent[v])
            {
                u = parent[v];
                pathFlow = Math.min(pathFlow, residualGraph[u][v]);
            }
            for (v = destination; v != source; v = parent[v])
            {
                u = parent[v];
                residualGraph[u][v] -= pathFlow;
                residualGraph[v][u] += pathFlow;
            }
            maxFlow += pathFlow;
        }

        /*calculate the cut set*/
        for (int vertex = 1; vertex <= numberOfVertices; vertex++)
        {
            if (bfs(source, vertex, residualGraph))
            {
                reachable.add(vertex);
            }
            else
            {  
                unreachable.add(vertex);
            }
        }
        for (int i = 0; i < reachable.size(); i++)
        {
            for (int j = 0; j < unreachable.size(); j++)
            {
                if (graph[reachable.get(i)][unreachable.get(j)] > 0)
                {
                    cutSet.add (new Pair(reachable.get(i), unreachable.get(j)));
                }
            }
        }
        return maxFlow;
    }

    public void printCutSet ()
    {
        Iterator<Pair> iterator = cutSet.iterator();
        while (iterator.hasNext())
        {
            Pair pair = iterator.next();
            System.out.println(pair.source + "-" + pair.destination);
        }
    }

    public static void main (String...arg)
    {
        int[][] graph;
        int numberOfNodes;
        int source;
        int sink;
        int maxFlow;

        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter the number of nodes");
        numberOfNodes = scanner.nextInt();
        graph = new int[numberOfNodes + 1][numberOfNodes + 1];

        System.out.println("Enter the graph matrix");
        for (int sourceVertex = 1; sourceVertex <= numberOfNodes; sourceVertex++)
        {
            for (int destinationVertex = 1; destinationVertex <= numberOfNodes; destinationVertex++)
            {
                graph[sourceVertex][destinationVertex] = scanner.nextInt();
            }
        }
        System.out.println("Enter the source of the graph");
        source= scanner.nextInt();

        System.out.println("Enter the sink of the graph");
        sink = scanner.nextInt();

        NetworkFlowProb networkFlowProb = new NetworkFlowProb(numberOfNodes);
        maxFlow = networkFlowProb.networkFlow(graph, source, sink);

        System.out.println("The Max flow in the graph is " + maxFlow);
        System.out.println("The Minimum Cut Set in the Graph is ");
        networkFlowProb.printCutSet();
        scanner.close();
    }
}

class Pair
{  
    public int source;
    public int destination;

    public Pair(int source, int destination)
    {
        this.source = source;
        this.destination = destination;
    }

    public Pair()
    {
    }
}



The Output of the program

Enter the number of nodes
6
Enter the graph matrix
0 16 13 0 0 0
0 0  10 12 0 0
0 4 0 0 14 0
0 0 9 0 0 20
0 0 0 7 0 4
0 0 0 0 0 0
Enter the source of the graph
1
Enter the sink of the graph
6
The Max flow in the graph is 23
The Minimum Cut Set in the Graph is
2-4
5-6
5-4

Image File Formets

   JPG, GIF, TIFF, PNG, BMP. What are they, and how do you choose? These and many other file types are used to encode digital images. The choices are simpler than you might think.

Part of the reason for the plethora of file types is the need for compression. Image files can be quite large, and larger file types mean more disk usage and slower downloads. Compression is a term used to describe ways of cutting the size of the file. Compression schemes can by lossy or lossless.

Another reason for the many file types is that images differ in the number of colors they contain. If an image has few colors, a file type can be designed to exploit this as a way of reducing file size.

Lossy vs. Lossless compression

You will often hear the terms "lossy" and "lossless" compression. A lossless compression algorithm discards no information. It looks for more efficient ways to represent an image, while making no compromises in accuracy. In contrast, lossy algorithms accept some degradation in the image in order to achieve smaller file size.

A lossless algorithm might, for example, look for a recurring pattern in the file, and replace each occurrence with a short abbreviation, thereby cutting the file size. In contrast, a lossy algorithm might store color information at a lower resolution than the image itself, since the eye is not so sensitive to changes in color of a small distance.

Number of colors

Images start with differing numbers of colors in them. The simplest images may contain only two colors, such as black and white, and will need only 1 bit to represent each pixel. Many early PC video cards would support only 16 fixed colors. Later cards would display 256 simultaneously, any of which could be chosen from a pool of 2²⁴, or 16 million colors. New cards devote 24 bits to each pixel, and are therefore capable of displaying 2²⁴, or 16 million colors without restriction. A few display even more. Since the eye has trouble distinguishing between similar colors, 24 bit or 16 million colors is often called TrueColor.

The file types

TIFF is, in principle, a very flexible format that can be lossless or lossy. The details of the image storage algorithm are included as part of the file. In practice, TIFF is used almost exclusively as a lossless image storage format that uses no compression at all. Most graphics programs that use TIFF do not compression. Consequently, file sizes are quite big. (Sometimes a lossless compression algorithm called LZW is used, but it is not universally supported.)

PNG is also a lossless storage format. However, in contrast with common TIFF usage, it looks for patterns in the image that it can use to compress file size. The compression is exactly reversible, so the image is recovered exactly.

GIF creates a table of up to 256 colors from a pool of 16 million. If the image has fewer than 256 colors, GIF can render the image exactly. When the image contains many colors, software that creates the GIF uses any of several algorithms to approximate the colors in the image with the limited palette of 256 colors available. Better algorithms search the image to find an optimum set of 256 colors. Sometimes GIF uses the nearest color to represent each pixel, and sometimes it uses "error diffusion" to adjust the color of nearby pixels to correct for the error in each pixel.

GIF achieves compression in two ways. First, it reduces the number of colors of color-rich images, thereby reducing the number of bits needed per pixel, as just described. Second, it replaces commonly occurring patterns (especially large areas of uniform color) with a short abbreviation: instead of storing "white, white, white, white, white," it stores "5 white."

Thus, GIF is "lossless" only for images with 256 colors or less. For a rich, true color image, GIF may "lose" 99.998% of the colors.

JPG is optimized for photographs and similar continuous tone images that contain many, many colors. It can achieve astounding compression ratios even while maintaining very high image quality. GIF compression is unkind to such images. JPG works by analyzing images and discarding kinds of information that the eye is least likely to notice. It stores information as 24 bit color. Important: the degree of compression of JPG is adjustable. At moderate compression levels of photographic images, it is very difficult for the eye to discern any difference from the original, even at extreme magnification. Compression factors of more than 20 are often quite acceptable. Better graphics programs, such as Paint Shop Pro and Photoshop, allow you to view the image quality and file size as a function of compression level, so that you can conveniently choose the balance between quality and file size.

RAW is an image output option available on some digital cameras. Though lossless, it is a factor of three of four smaller than TIFF files of the same image. The disadvantage is that there is a different RAW format for each manufacturer, and so you may have to use the manufacturer's software to view the images. (Some graphics applications can read some manufacturer's RAW formats.)

BMP is an uncompressed proprietary format invented by Microsoft. There is really no reason to ever use this format.

PSD, PSP, etc. , are proprietary formats used by graphics programs. Photoshop's files have the PSD extension, while Paint Shop Pro files use PSP. These are the preferred working formats as you edit images in the software, because only the proprietary formats retain all the editing power of the programs. These packages use layers, for example, to build complex images, and layer information may be lost in the nonproprietary formats such as TIFF and JPG. However, be sure to save your end result as a standard TIFF or JPG, or you may not be able to view it in a few years when your software has changed.

Currently, GIF and JPG are the formats used for nearly all web images. PNG is supported by most of the latest generation browsers. TIFF is not widely supported by web browsers, and should be avoided for web use. PNG does everything GIF does, and better, so expect to see PNG replace GIF in the future. PNG will not replace JPG, since JPG is capable of much greater compression of photographic images, even when set for quite minimal loss of quality.

File size comparisons

Below are comparisons of the same image saved in several popular file types. (Note that there is no reason to view more than one of the TIFFs or the PNG. Since all are lossless formats, their appearance is identical.)

File type	Size	Image Example
Tiff, uncompressed	901K	Not viewable in most browsers. Click here to try.
Tiff, LZW lossless compression (yes, its actually bigger)	928K	Not viewable in most browsers. Click here to try.
JPG, High quality	319K	Click here.
JPG, medium quality	188K	Click here.
JPG, my usual web quality	105K	Click here.
JPG, low quality / high compression	50K	Click here.
JPG, absurdly high compression	18K	Click here.
PNG, lossless compression	741K	Click here.
GIF, lossless compression, but only 256 colors	286K	Click here.

When should you use each?

TIFF

This is usually the best quality output from a digital camera. Digital cameras often offer around three JPG quality settings plus TIFF. Since JPG always means at least some loss of quality, TIFF means better quality. However, the file size is huge compared to even the best JPG setting, and the advantages may not be noticeable.

A more important use of TIFF is as the working storage format as you edit and manipulate digital images. You do not want to go through several load, edit, save cycles with JPG storage, as the degradation accumulates with each new save. One or two JPG saves at high quality may not be noticeable, but the tenth certainly will be. TIFF is lossless, so there is no degradation associated with saving a TIFF file.

Do NOT use TIFF for web images. They produce big files, and more importantly, most web browsers will not display TIFFs.

JPG

This is the format of choice for nearly all photographs on the web. You can achieve excellent quality even at rather high compression settings. I also use JPG as the ultimate format for all my digital photographs. If I edit a photo, I will use my software's proprietary format until finished, and then save the result as a JPG.

Digital cameras save in a JPG format by default. Switching to TIFF or RAW improves quality in principle, but the difference is difficult to see. Shooting in TIFF has two disadvantages compared to JPG: fewer photos per memory card, and a longer wait between photographs as the image transfers to the card. I rarely shoot in TIFF mode.

Never use JPG for line art. On images such as these with areas of uniform color with sharp edges, JPG does a poor job. These are tasks for which GIF and PNG are well suited. See JPG vs. GIF for web images.

GIF

If your image has fewer than 256 colors and contains large areas of uniform color, GIF is your choice. The files will be small yet perfect. Here is an example of an image well-suited for GIF:

Do NOT use GIF for photographic images, since it can contain only 256 colors per image.

PNG

PNG is of principal value in two applications:

1. If you have an image with large areas of exactly uniform color, but contains more than 256 colors, PNG is your choice. Its strategy is similar to that of GIF, but it supports 16 million colors, not just 256.
2. If you want to display a photograph exactly without loss on the web, PNG is your choice. Later generation web browsers support PNG, and PNG is the only lossless format that web browsers support.

PNG is superior to GIF. It produces smaller files and allows more colors. PNG also supports partial transparency. Partial transparency can be used for many useful purposes, such as fades and antialiasing of text. Unfortunately, Microsoft's Internet Explorer does not properly support PNG transparency, so for now web authors must avoid using transparency in PNG images.

Other formats

When using graphics software such as Photoshop or Paint Shop Pro, working files should be in the proprietary format of the software. Save final results in TIFF, PNG, or JPG.

Use RAW only for in-camera storage, and copy or convert to TIFF, PNG, or JPG as soon as you transfer to your PC. You do not want your image archives to be in a proprietary format. Although several graphics programs can now read the RAW format for many digital cameras, it is unwise to rely on any proprietary format for long term storage. Will you be able to read a RAW file in five years? In twenty? JPG is the format most likely to be readable in 50 years.Thus, it is appropriate to use RAW to store images in the camera and perhaps for temporary lossless storage on your PC, but be sure to create a TIFF, or better still a PNG or JPG, for archival storage.

Related pages

• Getting started in digital photography
• Tips and info on graphics, imaging, and digital photography
• JPG vs GIF for web images
• How bad is JPG? (Large file)
• Should you use JPG or a lossless format for archiving images? (Large file.)
• Chroma subsampling in JPG
• Miscellaneous tips and info