firedingo

CoreFileReader.java

Oct 19th, 2021
649
321 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package org.itc309.clyderiverapplication.desktop;
  2.  
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.net.URL;
  6. import java.util.Scanner;
  7.  
  8. public class CoreFileReader {
  9.     //private File path = new File("D:\\\\Uni\\\\ITC309\\\\ITC309-Team9\\\\App\\\\data\\\\");
  10.     private File file = new File("../data/salinity_levels.csv");
  11.     private File path = file;
  12.     private File directory = new File("../data/");
  13.     private int count = 0;
  14.     private String temp;
  15.     private Utility util = new Utility();
  16.     private int capacity = 11;
  17.     private int capacity1 = 100;
  18.     private int capacity2 = 40000;
  19.  
  20.     //Reads Salinity Levels in - in theory
  21.     public Number[] readData(String Location) {
  22.         //Setup
  23.         Number[] data = new Number[capacity1];
  24.         count = 0;
  25.         int j =0;
  26.        
  27.         if (Location == null) {
  28.             Location = "Test";
  29.         }
  30.        
  31.         //This could be cleaned up and made more efficient.
  32.         switch (Location) {
  33.             case "Test":
  34.                 setPath(18);
  35.                 util.printError("No Location Set. Falling Back To Default.");
  36.                 break;
  37.             case "Buoy 01 - Wray Street":
  38.                 setPath(1);
  39.                 break;
  40.             case "Buoy 03 - Moonlight":
  41.                 setPath(3);
  42.                 break;
  43.             case "Buoy 04 - Budd Island North":
  44.                 setPath(4);
  45.                 break;
  46.             case "Buoy 05 - Snapper Point North-West":
  47.                 setPath(5);
  48.                 break;
  49.             case "Fixed Depth - Rockey Point":
  50.                 setPath(14);
  51.                 break;
  52.             case "Buoy 08 - Angry Man Point":
  53.                 setPath(8);
  54.                 break;
  55.             case "Buoy 09 - Chinaman's Point":
  56.                 setPath(9);
  57.                 break;
  58.             case "Buoy 10 - Waterfall Creek":
  59.                 setPath(10);
  60.                 break;
  61.             case "Buoy 11 - Opposite Buckenbowra":
  62.                 setPath(11);
  63.                 break;
  64.             case "Buoy 12 - Big Island West":
  65.                 setPath(12);
  66.                 break;
  67.             case "Buoy 13 - Double Bay":
  68.                 setPath(13);
  69.                 break;
  70.         }
  71.        
  72.        
  73.         //read file
  74.         Scanner scanner = null;
  75.         try {
  76.             scanner = new Scanner(path);
  77.         } catch (FileNotFoundException e) {
  78.             // TODO Auto-generated catch block
  79.             System.err.println(e);
  80.         }
  81.         // put data into data structure
  82.         scanner.useDelimiter(",|\\n");
  83.         while (scanner.hasNext()) {
  84.             temp = scanner.next();
  85.             if (temp.contains(".")) {
  86.                 if (j < data.length) {
  87.                 data[j] = Float.parseFloat(temp);
  88.                 j++;
  89.                 }
  90.             }
  91.             System.out.println(temp);
  92.         }
  93.        
  94.         //Clean Up
  95.         scanner.close();
  96.        
  97.        
  98.         //Return To Parent
  99.         return data;
  100.     }
  101.  
  102.     //Reads The Time a measurement was taken in for all measurements
  103.     public String[] readTime(String Location) {
  104.         //Setup
  105.         String[] time = new String[capacity1];
  106.         count = 0;
  107.         int j = 0;
  108.        
  109.         if (Location == null) {
  110.             Location = "Test";
  111.         }
  112.  
  113.         //This could be cleaned up and made more efficient.
  114.         switch (Location) {
  115.             case "Test":
  116.                 setPath(18);
  117.                 util.printError("No Location Set. Falling Back To Default.");
  118.                 break;
  119.             case "Buoy 01 - Wray Street":
  120.                 setPath(1);
  121.                 break;
  122.             case "Buoy 03 - Moonlight":
  123.                 setPath(3);
  124.                 break;
  125.             case "Buoy 04 - Budd Island North":
  126.                 setPath(4);
  127.                 break;
  128.             case "Buoy 05 - Snapper Point North-West":
  129.                 setPath(5);
  130.                 break;
  131.             case "Fixed Depth - Rockey Point":
  132.                 setPath(14);
  133.                 break;
  134.             case "Buoy 08 - Angry Man Point":
  135.                 setPath(8);
  136.                 break;
  137.             case "Buoy 09 - Chinaman's Point":
  138.                 setPath(9);
  139.                 break;
  140.             case "Buoy 10 - Waterfall Creek":
  141.                 setPath(10);
  142.                 break;
  143.             case "Buoy 11 - Opposite Buckenbowra":
  144.                 setPath(11);
  145.                 break;
  146.             case "Buoy 12 - Big Island West":
  147.                 setPath(12);
  148.                 break;
  149.             case "Buoy 13 - Double Bay":
  150.                 setPath(13);
  151.                 break;
  152.             case "Budd Island":
  153.                 setPath(15);
  154.                 break;
  155.         }
  156.        
  157.         //read file
  158.         Scanner scanner = null;
  159.         try {
  160.             scanner = new Scanner(path);
  161.         } catch (FileNotFoundException e) {
  162.         // TODO Auto-generated catch block
  163.             System.err.println(e);
  164.             util.printError("The File Could Not Be Found Or Could Not Be Opened");
  165.         }
  166.        
  167.         // put data into data structure
  168.         //Skipping titles
  169.         for (int i=0; i<4; i++) {
  170.         scanner.next();
  171.         }
  172.        
  173.        
  174.         scanner.useDelimiter(",|\\n|T|\\+");
  175.        
  176.         while (scanner.hasNext()) {
  177.             temp = scanner.next();
  178.             if (temp.contains(":") && temp.length() == 8) {
  179.                 if (j < time.length) { 
  180.                     time[j] = temp;
  181.                     j++;
  182.                 }
  183.             }
  184.            
  185.         }
  186.        
  187.                
  188.         //Clean Up
  189.         scanner.close();
  190.        
  191.         //Return To Parent
  192.         return time;       
  193.     }
  194.    
  195.     //Reads in a list of all sensors from a file
  196.     public String[] readAllSensorsFile() {
  197.             path = new File("D:\\\\Uni\\\\ITC309\\\\ITC309-Team9\\\\App\\\\data\\\\sensor_list.txt");
  198.             Scanner scanner;
  199.             String[] sensors = new String[capacity];
  200.             count = 0;
  201.             try {
  202.                 scanner = new Scanner(path);
  203.                 util.printFeedback("INFO: File Successfully Found & Opened!");
  204.                
  205.                 while(scanner.hasNext()) {
  206.                    
  207.                     temp = scanner.nextLine();
  208.                     sensors[count] = temp;
  209.                     count++;
  210.                    
  211.                 }
  212.                
  213.             // The Error
  214.             } catch (FileNotFoundException e) {
  215.                 // TODO Auto-generated catch block
  216.                 e.printStackTrace();
  217.                 util.printError("The File Could Not Be Opened or Found");
  218.             }
  219.            
  220.             util.printData(sensors);
  221.             return sensors;
  222.            
  223.     }
  224.    
  225.     //Reads in a list of sensors from a file and filters out the harvest zones
  226.     public String[] readSensorsTextFile( ) {
  227.         path = new File("D:\\\\Uni\\\\ITC309\\\\ITC309-Team9\\\\App\\\\data\\\\sensor_list.txt");
  228.         Scanner scanner;
  229.         String[] sensors = new String[capacity];
  230.         count = 0;
  231.         try {
  232.             scanner = new Scanner(path);
  233.             util.printFeedback("INFO: File Successfully Found & Opened!");
  234.            
  235.             while(scanner.hasNext()) {
  236.                
  237.                 temp = scanner.nextLine();
  238.                
  239.  
  240.                     if (!(temp.equals("Buoy 03 - Moonlight")) ) {
  241.                         if (!(temp.equals("Fixed Depth - Rocky Point") )) {
  242.                             if (!(temp.equals("Buoy 10 - Waterfall Creek") ) ) {
  243.                                 sensors[count] = temp;
  244.                                 count++;
  245.                             }
  246.                         }
  247.                     }
  248.             }
  249.            
  250.         // The Error
  251.         } catch (FileNotFoundException e) {
  252.             // TODO Auto-generated catch block
  253.             e.printStackTrace();
  254.             util.printError("The File Could Not Be Opened or Found");
  255.         }
  256.        
  257.         util.printData(sensors);
  258.         return sensors;
  259.        
  260.     }
  261.    
  262.     //Reads in a list of sensors from a file and filters out all sensors that aren't harvest areas
  263.     public String[] readHarvestTextFile( ) {
  264.         setPath(2);
  265.         Scanner scanner;
  266.         String[] sensors = new String[capacity];
  267.         count = 0;
  268.         try {
  269.             scanner = new Scanner(path);
  270.             util.printFeedback("INFO: File Successfully Found & Opened!");
  271.            
  272.             while(scanner.hasNext()) {
  273.                
  274.                 temp = scanner.nextLine();
  275.                
  276.  
  277.                     if (temp.equals("Buoy 03 - Moonlight") ||
  278.                         (temp.equals("Fixed Depth - Rocky Point")) ||
  279.                         (temp.equals("Buoy 10 - Waterfall Creek")) ) {
  280.                                 sensors[count] = temp;
  281.                                 count++;
  282.                     }
  283.             }
  284.            
  285.         // The Error
  286.         } catch (FileNotFoundException e) {
  287.             // TODO Auto-generated catch block
  288.             e.printStackTrace();
  289.             util.printError("The File Could Not Be Opened or Found");
  290.         }
  291.        
  292.         util.printData(sensors);
  293.         return sensors;
  294.        
  295.     }
  296.    
  297.     //Reads in a favourite location from a file
  298.     public String readFavouriteLocation() {
  299.         setPath(16);
  300.         String fav = "";
  301.         try {
  302.             Scanner scanner = new Scanner(path);
  303.             while (scanner.hasNext()) {
  304.                 temp = scanner.nextLine();
  305.                 if (temp.contains("Favourite Location")) {
  306.                     fav = temp;
  307.                 }
  308.                
  309.             }
  310.            
  311.            
  312.         } catch (FileNotFoundException e) {
  313.             // TODO Auto-generated catch block
  314.             e.printStackTrace();
  315.             util.printError("The File Could Not Be Found And/Or Accessed");
  316.             util.printError("" + e.getLocalizedMessage());
  317.         }
  318.        
  319.        
  320.        
  321.         return fav;
  322.     }
  323.  
  324.     public Number[] readTemperatureData() {
  325.         setPath(15);
  326.         count = 0;
  327.         int j = 0;
  328.        
  329.         Number[] temperature = new Number[capacity1];
  330.        
  331.         try {
  332.             Scanner scanner = new Scanner(getPath());
  333.             scanner.useDelimiter(",|\\n");
  334.             util.printFeedback("INFO: The File Has Been Successfully Located & Opened");
  335.             util.printFeedback("INFO: " + getPath());
  336.             //Title Skip
  337.             for (int i = 0; i < 9; i++) {
  338.                 scanner.next();
  339.             }
  340.            
  341.             while (scanner.hasNext()) {
  342.            
  343.                 temp = scanner.next();
  344.                
  345.                 util.printFeedback("Temp Value: " + temp);
  346.                
  347.                 if (count == 6) {
  348.                     util.printFeedback("Count: " + count);
  349.                     util.printFeedback("Temp: " + temp);
  350.                    
  351.                    
  352.                         temperature[j] = Float.parseFloat(temp);
  353.                         util.printFeedback("Temperature["+j+"] = " + temperature[j]);
  354.                         j++;
  355.                    
  356.                 }
  357.                     count++;
  358.                
  359.                 if (count == 9) {
  360.                     count = 0;
  361.                 }
  362.                
  363.                
  364.                
  365.             }
  366.            
  367.                    
  368.            
  369.            
  370.         } catch (FileNotFoundException e) {
  371.             // TODO Auto-generated catch block
  372.             e.printStackTrace();
  373.         }
  374.        
  375.        
  376.         //Test
  377.         util.printFeedback("BEGIN TEMPERATURE PRINTOUT");
  378.         for (int i = 0; i<temperature.length; i++) {
  379.             util.printFeedback("Index " + i + ": " + temperature[i]);
  380.         }
  381.         util.printFeedback("END TEMPERATURE PRINTOUT");
  382.        
  383.         return temperature;
  384.     }
  385.    
  386.     public Number[] readRainfallData() {
  387.         setPath(15);
  388.         count = 0;
  389.         int j = 0;
  390.        
  391.         Number[] rainfall = new Number[capacity1];
  392.        
  393.         try {
  394.             Scanner scanner = new Scanner(getPath());
  395.             scanner.useDelimiter(",|\\n");
  396.            
  397.             //Title Skip
  398.             for (int i = 0; i < 9; i++) {
  399.                 scanner.next();
  400.             }
  401.            
  402.             while (scanner.hasNext()) {
  403.            
  404.                 temp = scanner.next();
  405.                
  406.                 util.printFeedback("Temp Value: " + temp);
  407.                
  408.                 if (count == 2) {
  409.                     util.printFeedback("Count: " + count);
  410.                     util.printFeedback("Temp: " + temp);
  411.                    
  412.                    
  413.                         rainfall[j] = Float.parseFloat(temp);
  414.                         util.printFeedback("Rainfall["+j+"] = " + rainfall[j]);
  415.                         j++;
  416.                    
  417.                 }
  418.                     count++;
  419.                
  420.                 if (count == 9) {
  421.                     count = 0;
  422.                 }
  423.                
  424.                
  425.                
  426.             }
  427.            
  428.                    
  429.            
  430.            
  431.         } catch (FileNotFoundException e) {
  432.             // TODO Auto-generated catch block
  433.             e.printStackTrace();
  434.         }
  435.        
  436.        
  437.         //Test
  438.         util.printFeedback("BEGIN RAINFALL PRINTOUT");
  439.         for (int i = 0; i<rainfall.length; i++) {
  440.             util.printFeedback("Index " + i + ": " + rainfall[i]);
  441.         }
  442.         util.printFeedback("END RAINFALL PRINTOUT");
  443.        
  444.         return rainfall;
  445.     }
  446.    
  447.     public void summariseData(String Location) {
  448.         Number[] allData = new Number[capacity1];
  449.         Number[] summaryData = new Number[capacity2];
  450.         int count = 0;
  451.         int count2 = 0;
  452.         int control = 0;
  453.        
  454.         allData = readData(Location);
  455.        
  456.         for (int a = 0; a < allData.length; a++) {
  457.            
  458.             for (int b = 0; b < summaryData.length; b++) {
  459.                 if (control == 0) {
  460.                     summaryData[count] = allData[a];
  461.                     count++;
  462.                 }
  463.                 control ++;
  464.                
  465.                 if (control == 3) {
  466.                     control = 0;
  467.                 }
  468.                
  469.             }
  470.         }
  471.        
  472.         //Test
  473.         System.out.println("BEGIN SUMMARY DATA OUTPUT");
  474.         for (int i=0; i<summaryData.length;i++) {
  475.             System.out.println("Index " + i + ": " + summaryData[i]);
  476.         }
  477.         System.out.println("END SUMMARY DATA OUTPUT");
  478.     }
  479.    
  480.    
  481.    
  482.    
  483.    
  484.    
  485.    
  486.    
  487.     public void setPath(int Selector) {
  488.         switch(Selector) {
  489.         case 0:
  490.             path = new File("Z:\\Fail.txt");
  491.             break;
  492.         case 16:
  493.             path = new File(directory + "\\preferences.txt");
  494.             break;
  495.         case 17:
  496.             path = new File(directory + "\\sensor_list.txt");
  497.             break;
  498.         case 18:
  499.             path = new File(directory + "\\salinity_levels.csv");
  500.             break;
  501.         case 1:
  502.             path = new File(directory + "\\sensor data\\buoy 01 - wray street\\salinity_levels.csv");
  503.             break;
  504.         case 3:
  505.             path = new File(directory + "\\sensor data\\buoy 03 - moonlight\\salinity_levels.csv");
  506.             break;
  507.         case 4:
  508.             path = new File(directory + "\\sensor data\\buoy 04 - budd island north\\salinity_levels.csv");
  509.             break;
  510.         case 5:
  511.             path = new File(directory + "\\sensor data\\buoy 05 - snapper point north-west\\salinity_levels.csv");
  512.             break;
  513.         case 8:
  514.             path = new File(directory + "\\sensor data\\buoy 08 - angry man point\\salinity_levels.csv");
  515.             break;
  516.         case 9:
  517.             path = new File(directory + "\\sensor data\\buoy 09 - chinamans point\\salinity_levels.csv");
  518.             break;
  519.         case 10:
  520.             path = new File(directory + "\\sensor data\\buoy 10 - waterfall creek\\salinity_levels.csv");
  521.             break;
  522.         case 11:
  523.             path = new File(directory + "\\sensor data\\buoy 11 - opposite buckenbowra\\salinity_levels.csv");
  524.             break;
  525.         case 12:
  526.             path = new File(directory + "\\sensor data\\buoy 12 - big island west\\salinity_levels.csv");
  527.             break;
  528.         case 13:
  529.             path = new File(directory + "\\sensor data\\buoy 13 - double bay\\salinity_levels.csv");
  530.             break;
  531.         case 14:
  532.             path = new File(directory + "\\sensor data\\fixed depth - rocky point\\salinity_levels.csv");
  533.             break;
  534.         case 15:
  535.             path = new File(directory + "\\sensor data\\weather station\\budd island.csv");
  536.             break;
  537.         }
  538.     }
  539.    
  540.     public File getPath() {
  541.         return path;
  542.     }
  543.    
  544. }
  545.  
RAW Paste Data