Amrita Cyber Java Library

Author: ramagururadhakrishnan

lib/jpl_20cys383/jpl_20cys383.iml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="json" level="project" />
+    <orderEntry type="library" name="googlecode.json.simple" level="project" />
+  </component>
+</module>

lib/jpl_20cys383/person.ser

@@ -0,0 +1,33 @@
+package com.ramaguru.amrita.cys.jpl.Streams;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/**
+ * An example demonstrating the usage of BufferedInputStream and BufferedOutputStream to improve I/O performance.
+ * This example reads data from the input file using BufferedInputStream and writes it to the output file using BufferedOutputStream.
+ *
+ * @author Ramaguru Radhakrishnan
+ * @version 0.5
+ */
+public class BufferedStreamExample {
+    /**
+     * Reads data from the input file using BufferedInputStream and writes it to the output file using BufferedOutputStream.
+     *
+     * @param args The command-line arguments.
+     */
+    public static void main(String[] args) {
+        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Projects_Java\\lib\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\files\\input.txt"));
+             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Projects_Java\\lib\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\files\\output.txt"))) {
+            int byteData;
+            while ((byteData = bis.read()) != -1) {
+                bos.write(byteData); // Write the byte data to the output file
+            }
+        } catch (IOException e) {
+            e.printStackTrace(); // Print the exception stack trace if an error occurs
+        }
+    }
+}

lib/jpl_20cys383/src/com/ramaguru/amrita/cys/jpl/Streams/BufferedStreamExample.java

@@ -0,0 +1,29 @@
+package com.ramaguru.amrita.cys.jpl.Streams;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+/**
+ * An example demonstrating the usage of ByteArrayInputStream to read data from a byte array.
+ *
+ * @author Ramaguru Radhakrishnan
+ * @version 0.5
+ */
+public class ByteArrayStreamExample {
+    /**
+     * Reads the data from the byte array and prints it to the console.
+     *
+     * @param args The command-line arguments.
+     */
+    public static void main(String[] args) {
+        byte[] data = { 50, 49, 85, 67, 89, 83 };
+        try (ByteArrayInputStream bais = new ByteArrayInputStream(data)) {
+            int byteData;
+            while ((byteData = bais.read()) != -1) {
+                System.out.print((char) byteData); // Convert the byte data to char and print
+            }
+        } catch (IOException e) {
+            e.printStackTrace(); // Print the exception stack trace if an error occurs
+        }
+    }
+}

lib/jpl_20cys383/src/com/ramaguru/amrita/cys/jpl/Streams/ByteArrayStreamExample.java

@@ -0,0 +1,39 @@
+package com.ramaguru.amrita.cys.jpl.Streams;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ * An example demonstrating the usage of DataInputStream and DataOutputStream to read and write primitive data types.
+ *
+ * @author Ramaguru Radhakrishnan
+ * @version 0.5
+ */
+public class DataStreamExample {
+    /**
+     * Writes an integer and a double value to the file using DataOutputStream,
+     * and then reads the values back using DataInputStream and prints them.
+     *
+     * @param args The command-line arguments.
+     */
+    public static void main(String[] args) {
+        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("C:\\Projects_Java\\lib\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\files\\data.bin"));
+             DataInputStream dis = new DataInputStream(new FileInputStream("C:\\Projects_Java\\lib\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\files\\data.bin"))) {
+            dos.writeInt(44); // Write the integer value
+            dos.writeDouble(3.14); // Write the double value
+            dos.writeChars("Ramaguru R"); // Write the String value
+
+            int intValue = dis.readInt(); // Read the integer value
+            double doubleValue = dis.readDouble(); // Read the double value
+            String stringvalue = Arrays.toString(dis.readAllBytes()); // Read the String value as Array
+
+            System.out.println("Read values: " + intValue + ", " + doubleValue + "," + stringvalue);
+        } catch (IOException e) {
+            e.printStackTrace(); // Print the exception stack trace if an error occurs
+        }
+    }
+}

lib/jpl_20cys383/src/com/ramaguru/amrita/cys/jpl/Streams/DataStreamExample.java

@@ -0,0 +1,28 @@
+package com.ramaguru.amrita.cys.jpl.Streams;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+
+/**
+ * An example demonstrating the usage of FileInputStream to read data from a file as a sequence of bytes.
+ *
+ * @author Ramaguru Radhakrishnan
+ * @version 0.5
+ */
+public class FileStreamExample {
+    /**
+     * Reads the data from the file and prints it to the console.
+     *
+     * @param args The command-line arguments.
+     */
+    public static void main(String[] args) {
+        try (FileInputStream fis = new FileInputStream("example.txt")) {
+            int data;
+            while ((data = fis.read()) != -1) {
+                System.out.print((char) data); // Convert the byte data to char and print
+            }
+        } catch (IOException e) {
+            e.printStackTrace(); // Print the exception stack trace if an error occurs
+        }
+    }
+}

lib/jpl_20cys383/src/com/ramaguru/amrita/cys/jpl/Streams/FileStreamExample.java

@@ -0,0 +1,31 @@
+package com.ramaguru.amrita.cys.jpl.Streams;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * An example demonstrating the usage of InputStreamReader to read data from an underlying input stream and convert it into characters.
+ *
+ * @author Ramaguru Radhakrishnan
+ * @version 0.5
+ */
+public class InputStreamReaderExample {
+    /**
+     * Reads the data from the input stream and prints it to the console.
+     *
+     * @param args The command-line arguments.
+     */
+    public static void main(String[] args) {
+        try (FileInputStream fis = new FileInputStream("C:\\Projects_Java\\lib\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\files\\example.txt");
+             InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8)) {
+            int charData;
+            while ((charData = isr.read()) != -1) {
+                System.out.print((char) charData); // Print the character data
+            }
+        } catch (IOException e) {
+            e.printStackTrace(); // Print the exception stack trace if an error occurs
+        }
+    }
+}

lib/jpl_20cys383/src/com/ramaguru/amrita/cys/jpl/Streams/InputStreamReaderExample.java

@@ -0,0 +1,66 @@
+package com.ramaguru.amrita.cys.jpl.Streams;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
+/**
+ * An example demonstrating the usage of ObjectInputStream and ObjectOutputStream to read and write objects.
+ *
+ * @author Ramaguru Radhakrishnan
+ * @version 0.5
+ */
+class Person implements Serializable {
+    private String name;
+    private int age;
+
+    /**
+     * Constructs a Person object with the specified name and age.
+     *
+     * @param name The name of the person.
+     * @param age  The age of the person.
+     */
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    @Override
+    public String toString() {
+        return "Person [name=" + name + ", age=" + age + "]";
+    }
+}
+
+/**
+ * An example demonstrating the usage of ObjectInputStream and ObjectOutputStream to read and write objects.
+ *
+ */
+public class ObjectStreamExample {
+    /**
+     * Serializes a Person object into a file and then deserializes it back.
+     *
+     * @param args The command-line arguments.
+     */
+    public static void main(String[] args) {
+        Person person = new Person("John", 25);
+
+        // Serialization
+        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Projects_Java\\lib\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\files\\person.ser"))) {
+            oos.writeObject(person);
+            System.out.println("Person object serialized and saved to 'person.ser'");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        // Deserialization
+        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Projects_Java\\lib\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\files\\person.ser"))) {
+            Person deserializedPerson = (Person) ois.readObject();
+            System.out.println("Deserialized Person: " + deserializedPerson);
+        } catch (IOException | ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

lib/jpl_20cys383/src/com/ramaguru/amrita/cys/jpl/Streams/ObjectStreamExample.java

@@ -0,0 +1,63 @@
+package com.ramaguru.amrita.cys.jpl.apps;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+
+/**
+ * The ImageSplicingDetection class is an application that detects splicing in an image.
+ * It reads an image file, performs splicing detection, and outputs the result.
+ *
+ * Dependencies:
+ * - Requires Java AWT and ImageIO libraries.
+ *
+ * Usage:
+ * - Specify the path to the image file in the 'imagePath' variable.
+ * - The 'detectSplicing' method contains the splicing detection algorithm, which can be implemented based on specific requirements.
+ * - The main method reads the image file, calls the 'detectSplicing' method, and displays the result.
+ *
+ * Note: This example includes a placeholder implementation for splicing detection that assumes all images are spliced.
+ *
+ * @author Ramaguru Radhakrishnan
+ * @version 0.5
+ */
+public class ImageSplicingDetection {
+
+    /**
+     * The main method is the entry point of the application.
+     * It reads an image file, performs splicing detection, and outputs the result.
+     *
+     * @param args command line arguments
+     */
+    public static void main(String[] args) {
+        String imagePath = "C:\\Projects_Java\\jpl_20cys383\\src\\com\\ramaguru\\amrita\\images\\21UCYS.jpeg";
+
+        try {
+            BufferedImage image = ImageIO.read(new File(imagePath));
+            boolean isSpliced = detectSplicing(image);
+
+            if (isSpliced) {
+                System.out.println("Image appears to be spliced.");
+            } else {
+                System.out.println("Image does not appear to be spliced.");
+            }
+        } catch (IOException e) {
+            System.out.println("Error reading the image: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Detects splicing in the given image.
+     * This method contains the splicing detection algorithm.
+     * Modify the implementation based on specific splicing detection requirements.
+     *
+     * @param image the image to be checked for splicing
+     * @return true if splicing is detected, false otherwise
+     */
+    public static boolean detectSplicing(BufferedImage image) {
+        // Implement your splicing detection algorithm here
+        // This is a placeholder implementation that assumes all images are spliced
+        return true;
+    }
+}