/*
* PlotLoader.java
*
* Created on December 31, 2006, 7:47 AM
*
*
* The NIST RCS (Real-time Control Systems)
* library is public domain software, however it is preferred
* that the following disclaimers be attached.
*
* Software Copywrite/Warranty Disclaimer
*
* This software was developed at the National Institute of Standards and
* Technology by employees of the Federal Government in the course of their
* official duties. Pursuant to title 17 Section 105 of the United States
* Code this software is not subject to copyright protection and is in the
* public domain. NIST Real-Time Control System software is an experimental
* system. NIST assumes no responsibility whatsoever for its use by other
* parties, and makes no guarantees, expressed or implied, about its
* quality, reliability, or any other characteristic. We would appreciate
* acknowledgement if the software is used. This software can be
* redistributed and/or modified freely provided that any derivative works
* bear some notice that they are derived from it, and any modified
* versions bear some notice that they have been modified.
*
*/
package dbgplot.ui;
import dbgplot.utils.URLLoadInfoPanelInterface;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.swing.JOptionPane;
/**
*
* @author shackle
*/
final class PlotLoader {
private int unnamed_num = 0;
private int point_number = 0;
private String url_string = null;
private int max_points_per_plot = 0;
private double max_x = Double.NEGATIVE_INFINITY;
private double min_x = Double.POSITIVE_INFINITY;
private double max_y = Double.NEGATIVE_INFINITY;
private double min_y = Double.POSITIVE_INFINITY;
private URLLoadInfoPanelInterface load_info_panel = null;
private PlotGraphJPanel plotGraphJPanel = null;
public void set_load_info_panel(URLLoadInfoPanelInterface _load_info_panel) {
load_info_panel = _load_info_panel;
}
public URLLoadInfoPanelInterface get_load_info_panel() {
return load_info_panel;
}
public int get_max_points_per_plot() {
return max_points_per_plot;
}
public void set_max_points_per_plot(int _max_points_per_plot) {
max_points_per_plot = _max_points_per_plot;
}
public void set_max_x(double _max_x) {
max_x = _max_x;
}
public double get_max_x() {
return max_x;
}
public void set_min_x(double _min_x) {
min_x = _min_x;
}
public double get_min_x() {
return min_x;
}
public void set_max_y(double _max_y) {
max_y = _max_y;
}
public double get_max_y() {
return max_y;
}
public void set_min_y(double _min_y) {
min_y = _min_y;
}
public double get_min_y() {
return min_y;
}
/** Creates a new instance of PlotLoader */
public PlotLoader(PlotGraphJPanel _plotGraphJPanel) {
try {
this.setPlotGraphJPanel(_plotGraphJPanel);
String max_lines_per_file_string = System.getProperty("max_lines");
if (null != max_lines_per_file_string) {
this.max_lines_per_file = Integer.valueOf(max_lines_per_file_string);
}
} catch (Exception e) {
}
}
private void AddPlot(PlotData pd, String name) {
plotGraphJPanel.AddPlot(pd, name.replace(' ', '_'));
}
private void AddPointToPlot(PlotData pd, double x, double y, boolean connected, double pre_f_x, double pre_f_y) {
if (x == pd.last_x && y == pd.last_y) {
PlotPoint pp = pd.getPlotPointAt(pd.last_added_plot_point_index);
if (pp != null && pp.pre_f_x == pre_f_x && pp.pre_f_y == pre_f_y) {
return;
}
}
plotGraphJPanel.AddPointToPlot(pd, x, y, connected, pre_f_x, pre_f_y);
}
private static boolean plot_verses_line_number = false;
private boolean first_line = true;
private int line = 0;
private boolean over_line_max = false;
private int skip_coords[] = null;
private int coords_map[] = null;
private boolean is_hex[] = null;
static public void set_plot_verses_line_number(boolean _plot_verses_line_number) {
plot_verses_line_number = _plot_verses_line_number;
}
private static boolean use_reverse_line_number = false;
static public void set_use_reverse_line_number(boolean _use_reverse_line_number) {
use_reverse_line_number = _use_reverse_line_number;
}
private static int start_at_line_number = -1;
static public void set_start_at_line_number(int _start_at_line_number) {
start_at_line_number = _start_at_line_number;
System.out.println("start_at_line_number = " + start_at_line_number);
}
private static int end_at_line_number = -1;
static public void set_end_at_line_number(int _end_at_line_number) {
end_at_line_number = _end_at_line_number;
}
private void ParseExtraCoordString(PlotData extra_pd, List<PlotData> extra_coord_plot_vector,
final String extra_coord_string, final int coord_num, final double x, final boolean connected) throws Exception {
double extra_coord = 0.0;
double y = 0.0;
final char first_char = extra_coord_string.charAt(0);
if (first_char == '"'
|| (!Character.isDigit(first_char)
&& first_char != '+' && first_char != '.' && first_char != '-')) {
return;
}
if ((null != is_hex && is_hex.length > coord_num && is_hex[coord_num]) || extra_coord_string.matches("0[0-9,A-F,a-f,x][0-9,A-F,a-f]*[A-F,a-f][0-9,A-F,a-f]*")) {
long l = Long.parseLong(extra_coord_string, 16);
if (null == is_hex || is_hex.length <= coord_num) {
boolean new_is_hex[] = new boolean[coord_num + 1];
if (null != is_hex) {
for (int j = 0; j < is_hex.length; j++) {
new_is_hex[j] = is_hex[j];
}
}
is_hex = new_is_hex;
}
if (!is_hex[coord_num]) {
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint("Value in field " + coord_num + " of " + extra_coord_string + " appears to be hexadecimal the field will be treeted as hex.");
}
is_hex[coord_num] = true;
}
extra_coord = l;
} else {
extra_coord = PlotLoader.parseDoubleValue(extra_coord_string);
}
if (extra_coord_plot_vector.size() > coord_num - 2) {
extra_pd = extra_coord_plot_vector.get(coord_num - 2);
}
if (null == extra_pd) {
extra_pd = new PlotData();
}
// System.out.println("extra_pd.name="+extra_pd.name+", string="+extra_coord_string);
y = extra_coord;
if (y > max_y) {
max_y = y;
}
if (y < min_y) {
min_y = y;
}
AddPointToPlot(extra_pd, x, y, connected, x, y);
if (extra_coord_plot_vector.size() < (coord_num - 1)) {
extra_coord_plot_vector.add(extra_pd);
} else {
extra_coord_plot_vector.set(coord_num-2,extra_pd);
}
}
private static boolean FIELD_SEPARATOR_SET = false;
private static String FIELD_SEPARATOR = ",";
public static void setFieldSeparator(String _FIELD_SEPARATOR) {
FIELD_SEPARATOR = _FIELD_SEPARATOR;
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint("_FIELD_SEPARATOR = " + _FIELD_SEPARATOR);
}
FIELD_SEPARATOR_SET = true;
}
private void ParseFirstLine(PlotData pd_to_use, List<PlotData> extra_coord_plot_vector, final String parseString) throws Exception {
skip_coords = null;
List<Integer> skip_coords_vector = new ArrayList<Integer>();
List<Integer> coord_map_vector = new ArrayList<Integer>();
if (!FIELD_SEPARATOR_SET && !cmd_line_mode) {
String new_field_separator = JOptionPane.showInputDialog("Field Separator", FIELD_SEPARATOR);
if (null != new_field_separator && new_field_separator.length() > 0) {
FIELD_SEPARATOR = new_field_separator;
}
FIELD_SEPARATOR_SET = true;
}
StringTokenizer tokenizer = new StringTokenizer(parseString, FIELD_SEPARATOR);
if (!tokenizer.hasMoreTokens()) {
return;
}
if (!PlotLoader.plot_verses_line_number && !this.url_string_ends_in_xy) {
String first_string = tokenizer.nextToken();
if (null != first_string) {
first_string = first_string.trim();
}
if (!tokenizer.hasMoreTokens()) {
if (pd_to_use.name != null && pd_to_use.name.length() > 1) {
return;
}
if (url_string != null && url_string.length() > 1) {
pd_to_use.name = url_string + "._" + first_string;
} else {
pd_to_use.name = "unnamed_" + unnamed_num + "._" + first_string;
}
pd_to_use.heading_string = first_string;
AddPlot(pd_to_use, pd_to_use.name);
return;
}
String second_string = tokenizer.nextToken();
if (null != second_string) {
second_string = second_string.trim();
}
if (pd_to_use.name == null || pd_to_use.name.length() < 1) {
if (url_string != null && url_string.length() > 1) {
pd_to_use.name = url_string + "._" + second_string;
} else {
pd_to_use.name = "unnamed_" + unnamed_num + "._" + second_string;
}
}
pd_to_use.heading_string = first_string;
AddPlot(pd_to_use, pd_to_use.name);
if (!tokenizer.hasMoreTokens()) {
return;
}
}
int extra_coord_pos = 0;
while (tokenizer.hasMoreTokens()) {
extra_coord_pos++;
String tok = tokenizer.nextToken();
if (null != tok) {
tok = tok.trim();
}
if (extra_coord_pos > extra_coord_plot_vector.size()) {
if (this.fieldSelectPatternEnabled) {
if (!tok.matches(this.fieldSelectPattern)) {
skip_coords_vector.add(Integer.valueOf(extra_coord_pos + 1));
coord_map_vector.add(Integer.valueOf(-3));
System.err.println("Field " + tok + " does NOT match pattern " + this.fieldSelectPattern + ".");
continue;
} else {
coord_map_vector.add(Integer.valueOf(extra_coord_plot_vector.size()));
System.err.println("Field " + tok + " matches pattern " + this.fieldSelectPattern + ". ");
}
}
PlotData extra_coord_plot_data = new PlotData();
if (extra_coord_plot_data.name != null && extra_coord_plot_data.name.length() > 1) {
return;
}
if (url_string != null && url_string.length() > 1) {
extra_coord_plot_data.name = url_string + "._" + tok;
} else {
extra_coord_plot_data.name = "unnamed_" + unnamed_num + "._" + tok;
}
extra_coord_plot_data.heading_string = tok;
AddPlot(extra_coord_plot_data, extra_coord_plot_data.name);
extra_coord_plot_vector.add(extra_coord_plot_data);
if (this.fieldSelectPatternEnabled) {
System.err.println(extra_coord_plot_vector.size() + " of " + extra_coord_pos + " fields selected.");
}
}
}
if (null != skip_coords_vector && skip_coords_vector.size() > 0) {
skip_coords = new int[skip_coords_vector.size()];
coords_map = new int[extra_coord_pos + 2];
for (int i = 0; i < skip_coords_vector.size(); i++) {
skip_coords[i] = skip_coords_vector.get(i).intValue();
}
coords_map[0] = -1;
coords_map[1] = -1;
for (int i = 0; i < coord_map_vector.size(); i++) {
coords_map[i + 2] = coord_map_vector.get(i).intValue() + 2;
}
}
// System.out.println("skip_coords="+skip_coords);
}
private boolean skip_coord_check(int coord) {
if (null == skip_coords) {
return false;
}
for (int i = 0; i < skip_coords.length; i++) {
//System.out.println("i="+i+", skip_coord[i]="+skip_coords[i]+",coord="+coord);
if (coord == skip_coords[i]) {
return true;
}
if (coord < skip_coords[i]) {
return false;
}
}
return false;
}
private double last_time_val = -1.0;
private static double time_val_diff_min = 0.001;
private static boolean check_time_val_diff = false;
private boolean time_val_checked = false;
static private int time_skip_count = 0;
static void set_time_diff_min(double _time_diff_min) {
time_val_diff_min = _time_diff_min;
check_time_val_diff = true;
time_skip_count = 0;
}
private boolean check_time_val(double time_val) {
if (time_val_checked || !check_time_val_diff) {
return false;
}
time_val_checked = true;
double diff = time_val - last_time_val;
if (diff > 0 && diff < time_val_diff_min) {
time_skip_count++;
return true;
}
last_time_val = time_val;
return false;
}
private static final SimpleDateFormat df =
new SimpleDateFormat("MM/dd/yy HH:mm:ss");
static private boolean first_parse_double_error_occured = false;
static double parseDoubleValue(String s) throws Exception {
Exception e1 = null;
try {
return Double.valueOf(s);
} catch (Exception e) {
e1 = e;
}
try {
df.setLenient(true);
//df.setTimeZone(TimeZone.getTimeZone("EDT"));
String dtstring = s;
String sfracstring = "";
double sfrac = 0;
String pattern = ".*[.][0-9][0-9][0-9]$";
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint(df.format(new Date()));
}
if (s.matches(pattern)) {
dtstring = s.substring(0, s.length() - 4);
sfracstring = s.substring(s.length() - 4);
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint("sfracstring = " + sfracstring);
}
sfrac = Double.valueOf(sfracstring);
} else {
System.err.println(s + " does not match " + pattern);
}
long l1 = df.parse(dtstring).getTime();
double d1 = (1e-3 * l1) + sfrac - 3600.0;
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint(String.format("parseDoubleValue(%s) returning %20.3f\n", s, d1));
}
return d1;
} catch (Exception e) {
if (!first_parse_double_error_occured) {
e.printStackTrace();
first_parse_double_error_occured = true;
}
if (null != e1) {
throw e1;
}
}
return Double.NEGATIVE_INFINITY;
}
private int pre_counted_line_count = -1;
@SuppressWarnings("unchecked")
private void ParseString(PlotData pd_to_use,
List<PlotData> extra_coord_plot_vector,
String parseString) throws Exception {
boolean connected = true;
PlotData extra_pd = null;
time_val_checked = false;
if (this.fieldSelectPatternEnabled) {
PlotLoader.plot_verses_line_number = true;
}
if (first_line) {
line = 0;
over_line_max = false;
} else {
line++;
if (over_line_max) {
return;
}
if (line > this.max_lines_per_file && this.max_lines_per_file >= 0) {
over_line_max = true;
throw new Exception("Line limit exceeded. " + line + " > " + max_lines_per_file);
}
}
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint("ParseString( pd_to_use=" + pd_to_use + ", parseString=" + parseString + ")");
PlotterCommon.DebugPrint("pd_to_use.name=" + pd_to_use.name);
}
if (first_line
&& (Character.isDigit(parseString.charAt(0))
|| parseString.charAt(0) == '+'
|| parseString.charAt(0) == '-'
|| parseString.charAt(0) == '.')) {
StringTokenizer st = new StringTokenizer(parseString, PlotLoader.FIELD_SEPARATOR);
String fakeFirstLine = "";
int token_num = 0;
while (st.hasMoreTokens()) {
token_num++;
fakeFirstLine += "field" + token_num;
if (st.hasMoreTokens()) {
fakeFirstLine += PlotLoader.FIELD_SEPARATOR.charAt(0);
}
st.nextToken();
}
if (token_num == 2 && url_string_ends_in_xy) {
fakeFirstLine = "x,y";
}
ParseFirstLine(pd_to_use, extra_coord_plot_vector, fakeFirstLine);
}
if ((parseString.charAt(0) == '"' || first_line)
&& !Character.isDigit(parseString.charAt(0))
&& parseString.charAt(0) != '+'
&& parseString.charAt(0) != '-'
&& parseString.charAt(0) != '.') {
boolean starts_with_quote = false;
if (parseString.charAt(0) == '"') {
starts_with_quote = true;
parseString = parseString.substring(1);
int qindex = parseString.indexOf('"');
if (qindex > 0) {
parseString = parseString.substring(0, qindex);
}
pd_to_use = new PlotData();
pd_to_use.name = parseString;
}
if (parseString.length() < 1) {
return;
}
if (starts_with_quote) {
if (pd_to_use.name.length() > 0 || pd_to_use.current_size > 0) {
if (pd_to_use.name.length() < 1) {
unnamed_num++;
if (url_string != null && url_string.length() > 1) {
pd_to_use.name = url_string + unnamed_num;
} else {
pd_to_use.name = "unnamed_" + unnamed_num;
}
}
AddPlot(pd_to_use, pd_to_use.name);
if (null != extra_coord_plot_vector) {
for (int i = 0; i < extra_coord_plot_vector.size(); i++) {
extra_pd = extra_coord_plot_vector.get(i);
if (null != extra_pd.heading_string) {
extra_pd.name = extra_pd.heading_string;
} else {
extra_pd.name = pd_to_use.name + "_coord_" + i;
}
AddPlot(extra_pd, extra_pd.name);
}
extra_coord_plot_vector = null;
extra_pd = null;
}
pd_to_use = new PlotData();
}
pd_to_use.name = parseString;
point_number = 0;
} else if (first_line) {
ParseFirstLine(pd_to_use, extra_coord_plot_vector, parseString);
first_line = false;
point_number = 0;
return;
}
return;
}
first_line = false;
StringTokenizer tokenizer = new StringTokenizer(parseString, FIELD_SEPARATOR);
if (!tokenizer.hasMoreTokens()) {
return;
}
double first_coord = 0.0;
double second_coord = 0.0;
double x = 0.0;
double y = 0.0;
point_number++;
if(point_number < start_at_line_number) {
// System.err.println("Skipping point_number="+point_number);
// System.err.println("start_at_line_number="+start_at_line_number);
return;
}
if(point_number > end_at_line_number && end_at_line_number > 0) {
// System.err.println("Skipping point_number="+point_number);
// System.err.println("end_at_line_number="+end_at_line_number);
return;
}
System.out.println("point_number="+point_number+" , parseString="+parseString);
if (!PlotLoader.plot_verses_line_number && !this.url_string_ends_in_xy) {
try {
String first_string = tokenizer.nextToken();
if (null != first_string) {
first_string = first_string.trim();
}
first_coord = parseDoubleValue(first_string);
if (check_time_val(first_coord)) {
return;
}
} catch (Exception e) {
return;
}
if (!tokenizer.hasMoreTokens()) {
second_coord = first_coord;
first_coord = point_number;
if(use_reverse_line_number) {
first_coord = this.counted_lines - point_number;
}
} else {
try {
String second_string = tokenizer.nextToken();
if (null != second_string) {
second_string = second_string.trim();
}
second_coord = parseDoubleValue(second_string);
if (check_time_val(second_coord)) {
return;
}
} catch (Exception e) {
second_coord = first_coord;
first_coord = point_number;
if(use_reverse_line_number) {
first_coord = this.counted_lines - point_number;
}
}
}
} else {
first_coord = point_number;
if(use_reverse_line_number) {
first_coord = this.counted_lines - point_number;
}
}
if (pd_to_use.coordinate_type == PlotterCommon.POLAR_COORD_TYPE) {
double r = first_coord;
double theta = second_coord;
} else {
x = first_coord;
y = second_coord;
}
if (!this.fieldSelectPatternEnabled || !skip_coord_check(0)) {
AddPointToPlot(pd_to_use, x, y, connected, x, y);
}
int coord_num = 2;
if (extra_coord_plot_vector == null) {
return;
}
while (tokenizer.hasMoreTokens()) {
String extra_coord_string = null;
try {
extra_coord_string = tokenizer.nextToken();
if (null != extra_coord_string) {
extra_coord_string = extra_coord_string.trim();
}
} catch (Exception e) {
break;
}
try {
if (coord_num == 2 && time_val_checked
&& check_time_val(Double.valueOf(extra_coord_string))) {
return;
}
} catch (Exception exception) {
exception.printStackTrace();
}
int coord_to_use = coord_num;
if (!this.fieldSelectPatternEnabled ||
(coord_num < coords_map.length &&
(coord_to_use = coords_map[coord_num]) >= 2)) {
ParseExtraCoordString(extra_pd, extra_coord_plot_vector, extra_coord_string, coord_to_use, x, connected);
}
extra_pd = null;
coord_num++;
}
}
private boolean count_lines_first = true;
private boolean use_fixed_plotdata = false;
private int counted_lines = -1;
private int skipped_lines = 0;
private int lines_to_skip = 0;
private void CountLines(BufferedReader reader) throws Exception {
while (null != reader.readLine()) {
counted_lines++;
}
}
private void SkipLines(BufferedReader reader, int lines_to_skip) throws Exception {
skipped_lines = 0;
while (null != reader.readLine() && skipped_lines < lines_to_skip) {
skipped_lines++;
}
}
private int lines_read = 0;
public void Reload() {
lines_to_skip = 0;
if (lines_read < counted_lines && lines_read > 100) {
lines_to_skip = lines_read - 2;
}
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint("lines_read=" + lines_read + ", counted_lines=" + counted_lines + ", lines_to_skip=" + lines_to_skip);
}
LoadURL(url_string);
}
boolean url_string_ends_in_xy = false;
protected String LineFilterPattern;
/**
* Get the value of LineFilterPattern
*
* @return the value of LineFilterPattern
*/
public String getLineFilterPattern() {
return LineFilterPattern;
}
/**
* Set the value of LineFilterPattern
*
* @param LineFilterPattern new value of LineFilterPattern
*/
public void setLineFilterPattern(String LineFilterPattern) {
this.LineFilterPattern = LineFilterPattern;
}
public static boolean cmd_line_mode = false;
public static int filenum = 0;
public void LoadURL(String _url_string) {
byte b[] = new byte[32768];
long load_url_start_time = System.currentTimeMillis();
try {
PlotData plot_data_to_add = null;
List<PlotData> extra_coords_plots_vector = new ArrayList<PlotData>();
URL newURL = null;
URLConnection newURLConnection = null;
File newFile = null;
FileInputStream newFileInputStream = null;
BufferedReader reader = null;
PlotData extra_pd = null;
url_string = _url_string;
counted_lines = -1;
long mem_used_start = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
if (Thread.interrupted()) {
return;
}
if(use_reverse_line_number) {
this.count_lines_first = true;
}
if (url_string.startsWith("http:") || url_string.startsWith("ftp:")) {
newURL = new URL(url_string);
newURLConnection = newURL.openConnection();
newURLConnection.setUseCaches(false);
reader = new BufferedReader(new InputStreamReader(newURLConnection.getInputStream()));
try {
if (null != load_info_panel) {
load_info_panel.set_content_length(newURLConnection.getContentLength());
}
} catch (Exception e) {
System.err.println("Error initializing load_info_panel.");
e.printStackTrace();
}
} else {
newFile = new File(url_string);
newFileInputStream = new FileInputStream(url_string);
reader = new BufferedReader(new InputStreamReader(newFileInputStream));
if (count_lines_first) {
CountLines(reader);
reader.close();
newFileInputStream.close();
newFileInputStream = new FileInputStream(url_string);
reader = new BufferedReader(new InputStreamReader(newFileInputStream));
if (use_fixed_plotdata) {
PlotData.fixed_size = counted_lines;
plotGraphJPanel.max_points_per_plot = counted_lines;
}
}
try {
if (null != load_info_panel) {
load_info_panel.set_content_length((int) newFile.length());
}
} catch (Exception e) {
System.err.println("Error initializing load_info_panel.");
e.printStackTrace();
}
}
if (!cmd_line_mode && filenum == 0) {
String new_line_filter_pattern =
JOptionPane.showInputDialog("Pattern to filter lines",
this.LineFilterPattern);
if (null != new_line_filter_pattern) {
this.setLineFilterPattern(new_line_filter_pattern);
}
Boolean BV[] = new Boolean[2];
BV[0] = Boolean.FALSE;
BV[1] = Boolean.TRUE;
Boolean B = (Boolean)
JOptionPane.showInputDialog(plotGraphJPanel,
"Plot values versus line number?", "Plotter Query",
JOptionPane.QUESTION_MESSAGE, null, BV, Boolean.valueOf(PlotLoader.plot_verses_line_number));
if (B != null) {
PlotLoader.plot_verses_line_number = B.booleanValue();
}
}
first_line = true;
point_number = 0;
url_string_ends_in_xy = _url_string.endsWith(".xy");
if (url_string_ends_in_xy) {
plot_verses_line_number = true;
}
String parseString = null;
if (lines_to_skip > 0) {
plot_data_to_add = new PlotData();
if (first_line && _url_string.endsWith(".xyz")
&& (Character.isDigit(parseString.charAt(0)) || parseString.charAt(0) == '-' || parseString.charAt(0) == '+')) {
ParseString(plot_data_to_add, extra_coords_plots_vector, "X, Y, Z\n");
} else {
parseString = reader.readLine();
if (null != parseString) {
parseString = parseString.trim();
}
ParseString(plot_data_to_add, extra_coords_plots_vector, parseString);
}
SkipLines(reader, lines_to_skip);
lines_read = 1 + lines_to_skip;
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint("skipped_lines=" + skipped_lines);
}
} else {
skipped_lines = 0;
}
try {
int lines_between_updates = 20;
if (null != load_info_panel) {
lines_between_updates = load_info_panel.get_content_length() / 1000;
}
if (lines_between_updates < 20) {
lines_between_updates = 20;
}
if (null == plot_data_to_add) {
plot_data_to_add = new PlotData();
}
try {
if (null != load_info_panel) {
load_info_panel.set_bytes_read(0);
load_info_panel.set_URLname(url_string);
}
} catch (Exception e) {
System.err.println("Error initializing load_info_panel.");
e.printStackTrace();
}
//StringBuffer tempBuffer = new StringBuffer();
while (true) {
if (lines_read > skipped_lines) {
long memleft = Runtime.getRuntime().maxMemory() - Runtime.getRuntime().totalMemory() + Runtime.getRuntime().freeMemory();
long mem_used = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
long mem_used_new = mem_used - mem_used_start;
long mem_used_per_line = (mem_used_new) / (lines_read - skipped_lines);
// System.out.println("lines_read= "+lines_read+", memleft = "+memleft+", mem_used="+mem_used+", mem_used_new="+mem_used_new+", mem_used_per_line="+mem_used_per_line);
if (lines_read - skipped_lines > 50000
&& memleft < 10000000) {
this.max_lines_per_file = lines_read / 2;
return;
}
}
if (Thread.interrupted()) {
return;
}
try {
parseString = reader.readLine();
if (null != parseString) {
parseString = parseString.trim();
}
} catch (java.lang.OutOfMemoryError oome) {
this.max_lines_per_file = lines_read / 2;
// oome.printStackTrace();
return;
}
if (null == parseString) {
break;
}
if (parseString.length() < 1) {
continue;
}
if (null != this.LineFilterPattern && this.LineFilterPattern.length() > 0) {
if (!parseString.matches(this.LineFilterPattern)) {
continue;
}
}
// if(!parseString.endsWith("\n") && !parseString.endsWith("\n\r"))
// {
// tempBuffer.append(parseString+"\n");
// }
// else
// {
// tempBuffer.append(parseString);
// }
try {
// NOT a breakpoint
if (load_info_panel != null) {
load_info_panel.inc_bytes_read(parseString.length());
if (lines_read % (lines_between_updates) == 0) {
load_info_panel.updateDisplay();
Thread.sleep(10);
}
}
} catch (Exception e) {
System.err.println("Error updating load_info_panel.");
e.printStackTrace();
}
// String s=parseString;
// if(s.startsWith("##! "))
// {
// s = s.substring(4);
// }
// if(
// s.charAt(0) == '#' ||
// s.charAt(0) == '!' ||
// s.startsWith("plot -") ||
// s.startsWith("pause") ||
// s.equals("e"))
// {
// continue;
// }
if (parseString.charAt(0) == '"' && parseString.endsWith("\"") && parseString.length() > 2 && parseString.indexOf(' ') < 0 && parseString.indexOf(',') < 0 && parseString.indexOf('\t') < 0) {
String newname = parseString.substring(1, parseString.length() - 1);
if (newname.compareTo(plot_data_to_add.name) != 0) {
if (plot_data_to_add.current_size > 0) {
plotGraphJPanel.AddPlot(plot_data_to_add, plot_data_to_add.name);
plot_data_to_add = new PlotData();
plot_data_to_add.name = newname;
} else {
plot_data_to_add.name = newname;
}
}
} else {
try {
if (first_line && _url_string.endsWith(".xyz")
&& (Character.isDigit(parseString.charAt(0)) || parseString.charAt(0) == '-' || parseString.charAt(0) == '+')) {
ParseString(plot_data_to_add, extra_coords_plots_vector, "X, Y, Z\n");
}
ParseString(plot_data_to_add, extra_coords_plots_vector, parseString);
} catch (java.lang.OutOfMemoryError oome) {
this.max_lines_per_file = lines_read / 2;
// oome.printStackTrace();
return;
}
}
lines_read++;
}
// if(plot_data_to_add.name.length() > 0 || plot_data_to_add.current_size > 0)
// {
// if(plot_data_to_add.name.length() < 1)
// {
// unnamed_num++;
// if(url_string != null && url_string.length() > 1)
// {
// plot_data_to_add.name = url_string+unnamed_num;
// }
// else
// {
// plot_data_to_add.name = "unnamed_"+unnamed_num;
// }
// }
// AddPlot(plot_data_to_add,plot_data_to_add.name);
// if(null != extra_pds_vector)
// {
// for(int i = 0; i < extra_pds_vector.size(); i++)
// {
// extra_pd = (PlotData) extra_pds_vector.elementAt(i);
// extra_pd.name = plot_data_to_add.name+"_coord_"+(i+2);
// AddPlot(extra_pd,extra_pd.name);
// }
// extra_pds_vector=null;
// extra_pd=null;
// }
// }
} finally {
if (null != reader) {
reader.close();
reader = null;
}
if (null != newFileInputStream) {
newFileInputStream.close();
newFileInputStream = null;
}
}
//PlotterCommon.DebugPrint2("PlotGraph.plots= "+PlotGraph.plots);
// if(PlotGraph.keyVector != null)
// {
// //PlotterCommon.DebugPrint2("PlotGraph.plots.size() = "+PlotGraph.plots.size());
// int max_now=0;
// for(int ki = 0 ; ki < PlotGraph.keyVector.size(); ki++)
// {
// PlotData plot_data = (PlotData) PlotGraph.keyVector.elementAt(ki);
// if(PlotterCommon.debug_on )
// {
// PlotterCommon.DebugPrint("plot_data.name="+plot_data.name+", plot_data.v.size() g= " +plot_data.v_size());
// }
// if(plot_data.v_size() > max_now)
// {
// max_now = plot_data.v_size();
// }
// }
// if(PlotterCommon.debug_on )
// {
// PlotterCommon.DebugPrint("max_now="+max_now);
// }
// if(max_now > max_points_per_plot)
// {
// set_max_points_per_plot(max_now);
// }
// }
} catch (Exception e) {
e.printStackTrace();
} finally {
b = null;
System.gc();
}
long load_url_stop_time = System.currentTimeMillis();
long load_url_time = load_url_stop_time - load_url_start_time;
if (PlotterCommon.debug_on) {
PlotterCommon.DebugPrint("load_url_time= " + load_url_time);
if (time_skip_count > 0) {
PlotterCommon.DebugPrint("time_skip_count = " + time_skip_count);
}
}
b = null;
//ListPlots();
}
/**
* Holds value of property max_lines_per_file.
*/
private int max_lines_per_file = -1;
/**
* Getter for property max_lines_per_file.
* @return Value of property max_lines_per_file.
*/
public int getMax_lines_per_file() {
return this.max_lines_per_file;
}
/**
* Setter for property max_lines_per_file.
* @param max_lines_per_file New value of property max_lines_per_file.
*/
public void setMax_lines_per_file(int max_lines_per_file) {
this.max_lines_per_file = max_lines_per_file;
}
/**
* Holds value of property fieldSelectPattern.
*/
private String fieldSelectPattern;
/**
* Getter for property fieldSelectPattern.
* @return Value of property fieldSelectPattern.
*/
public String getFieldSelectPattern() {
return this.fieldSelectPattern;
}
/**
* Setter for property fieldSelectPattern.
* @param fieldSelectPattern New value of property fieldSelectPattern.
*/
public void setFieldSelectPattern(String fieldSelectPattern) {
this.fieldSelectPattern = fieldSelectPattern;
}
/**
* Holds value of property fieldSelectPatternEnabled.
*/
private boolean fieldSelectPatternEnabled;
/**
* Getter for property fieldSelectPatternEnabled.
* @return Value of property fieldSelectPatternEnabled.
*/
public boolean isFieldSelectPatternEnabled() {
return this.fieldSelectPatternEnabled;
}
/**
* Setter for property fieldSelectPatternEnabled.
* @param fieldSelectPatternEnabled New value of property fieldSelectPatternEnabled.
*/
public void setFieldSelectPatternEnabled(boolean fieldSelectPatternEnabled) {
this.fieldSelectPatternEnabled = fieldSelectPatternEnabled;
}
/**
* @return the plotGraphJPanel
*/
public PlotGraphJPanel getPlotGraphJPanel() {
return plotGraphJPanel;
}
/**
* @param plotGraphJPanel the plotGraphJPanel to set
*/
public void setPlotGraphJPanel(PlotGraphJPanel plotGraphJPanel) {
this.plotGraphJPanel = plotGraphJPanel;
}
}