diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..221cb315
Binary files /dev/null and b/.DS_Store differ
diff --git a/.github/workflows/testrun.yml b/.github/workflows/testrun.yml
index 8adf1062..d40c41e6 100644
--- a/.github/workflows/testrun.yml
+++ b/.github/workflows/testrun.yml
@@ -20,13 +20,3 @@ jobs:
run: |
echo Running install
make install
- - name: "Run a simple graph"
- run: |
- cd scripts
- echo Trying to create graph
- ./creategraphfromdate.sh 2000 09
- - name: Upload graph image
- uses: actions/upload-artifact@v1
- with:
- name: Upload graph
- path: testrun/bview_2000_09/bview_2000_09_transparent.png
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index dee24d5d..6d917b17 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,9 @@
tags
+tagsfile
*.o
+.*.un~
+.*.swp
+.swp
/bin/lglayout2D
/bin/lglayout3D
/bin/lglbreakup
@@ -24,4 +28,5 @@ src/lglbreakup
src/lglfileconvert
src/lglayout
src/lglrebuild
-**/*.pyx
\ No newline at end of file
+**/*.pyx
+.DS_Store
diff --git a/Java/Makefile b/Java/Makefile
index fad9a43c..0ef97a28 100644
--- a/Java/Makefile
+++ b/Java/Makefile
@@ -10,7 +10,7 @@ jar/%.jar: $(CLASS)
jarfiles: jar/ImageMaker.jar jar/LGLLib.jar jar/LGLView.jar
%.class : %.java
- javac -cp lib/Jama-1.0.3.jar:lib/VectorGraphics2D-0.13.jar src/Viewer2D/*.java src/ImageMaker/*.java
+ javac -cp lib/Jama-1.0.3.jar:lib/VectorGraphics2D-0.13.jar -cp src src/Viewer2D/*.java src/ImageMaker/*.java
all: $(CLASS)
diff --git a/Java/jar/ImageMaker.jar b/Java/jar/ImageMaker.jar
index 14efc7d8..e9fce429 100644
Binary files a/Java/jar/ImageMaker.jar and b/Java/jar/ImageMaker.jar differ
diff --git a/Java/jar/LGLLib.jar b/Java/jar/LGLLib.jar
index a59394bd..2951c849 100644
Binary files a/Java/jar/LGLLib.jar and b/Java/jar/LGLLib.jar differ
diff --git a/Java/jar/LGLView.jar b/Java/jar/LGLView.jar
index 77195ec0..c2d4c9bd 100644
Binary files a/Java/jar/LGLView.jar and b/Java/jar/LGLView.jar differ
diff --git a/Java/src/ImageMaker/GenerateImages.java b/Java/src/ImageMaker/GenerateImages.java
index 51315f57..56fc1eff 100755
--- a/Java/src/ImageMaker/GenerateImages.java
+++ b/Java/src/ImageMaker/GenerateImages.java
@@ -1,321 +1,335 @@
-//
-// Copyright (c) 2003 Alex Adai, All Rights Reserved.
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of
-// the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston,
-// MA 02111-1307 USA
-//
-
-package ImageMaker;
-
-import java.awt.Color;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-
-import Viewer2D.EdgesPanel;
-import Viewer2D.FormatVertex;
-import Viewer2D.ViewerIO;
-import de.erichseifert.vectorgraphics2d.Document;
-import de.erichseifert.vectorgraphics2d.Processor;
-import de.erichseifert.vectorgraphics2d.Processors;
-import de.erichseifert.vectorgraphics2d.VectorGraphics2D;
-import de.erichseifert.vectorgraphics2d.intermediate.CommandSequence;
-import de.erichseifert.vectorgraphics2d.util.PageSize;
-
-/**
- * SESS - 2014.05.10:
- *
- *
Cleanup code a little bit.
- *
Allow user to include edge color file ("-c <file>" at the end of
- * the command line).
- *
- *
- */
-public class GenerateImages {
- public static Color EDGE_COLOR = Color.white;
- public static String EDGE_COLOR_FILE = "color_file";
-
- public static void main(String[] args) {
- boolean loadedEdgeColors = false;
- if (args.length == 0) {
- message();
- }
-
- int[] windowSizes = new int[2];
- windowSizes[0] = new Integer(args[0]).intValue();
- windowSizes[1] = new Integer(args[1]).intValue();
- System.out.println("Loading flindeberg mod 2");
- System.out.println("Image size is " + windowSizes[0] + " x "
- + windowSizes[1]);
-
- // Check params
- String edgeFile = args[2];
- String edgeColorFile = EDGE_COLOR_FILE;
- List coordFiles = new ArrayList();
- boolean colorFileSwitch = false;
- for (int i = 3; i < args.length; i++) {
- String arg = args[i];
- if ("-c".equals(arg)) {
- colorFileSwitch = true;
- continue;
- }
- if (colorFileSwitch) {
- edgeColorFile = arg;
- break;
- }
- coordFiles.add(arg);
- }
- if (coordFiles.isEmpty()) {
- message();
- }
-
- System.out.println("Loading edge file: " + edgeFile + "...");
- ViewerIO verterIO = null;
- try {
- verterIO = new ViewerIO(new File(edgeFile));
- verterIO.loadSHORTFile();
- } catch (IOException e) {
- System.out.println(e.getMessage());
- System.exit(1);
- }
- System.out.println("Trying to load edge color file: " + edgeColorFile
- + "...");
- try {
- verterIO.loadEdgeColorFile(new File(edgeColorFile));
- loadedEdgeColors = true;
- } catch (java.io.FileNotFoundException e) {
- loadedEdgeColors = false;
- System.out.println(e.getMessage());
- } catch (java.io.IOException e) {
- System.out.println(e.getMessage());
- System.exit(1);
- }
- System.out.println("Edges loading complete.");
-
- generateDark(loadedEdgeColors, windowSizes, coordFiles, verterIO);
-
- generateLight(loadedEdgeColors, windowSizes, coordFiles, verterIO);
-
- generateTransparent(loadedEdgeColors, windowSizes, coordFiles, verterIO);
-
- // System.out.println("Going for vector graphics (currently broken)");
- // // Lets process coords files
- // for (String coordFile : coordFiles) {
- // try {
- // System.out.println("Loading " + coordFile + "...");
- // verterIO.loadVertexCoords(new File(coordFile));
-
-
- // FormatVertex formatter = new FormatVertex(
- // verterIO.getVertices(), verterIO.getStats(),
- // windowSizes, 1);
-
- // EdgesPanel panel = new EdgesPanel(verterIO.getEdges(),
- // verterIO.getVertices(), windowSizes[0], windowSizes[1]);
-
- // if (loadedEdgeColors)
- // panel.addEdgeColors(verterIO.getEdgeColorMap());
-
- // panel.showVertices(true);
- // panel.setVisibilityTest(true);
- // panel.setFormatter(formatter);
- // panel.setEdgeColor(EDGE_COLOR);
- // panel.setVertexColor(Color.white);
- // panel.setBackgroundColor(new Color(0f,0f,0f,0f));
-
- // // Use vector instead
- // VectorGraphics2D g2 = new VectorGraphics2D();
-
- // // Now the image has to be fitted to the given region
- // panel.fitData();
- // panel.writeVectorImage(g2);
-
- // CommandSequence commands = ((VectorGraphics2D) g2).getCommands();
-
- // String[] elements = {"pdf", "eps", "svg"};
- // for (String ext : elements) {
-
- // Processor pdfProcessor = Processors.get(ext);
- // Document doc = pdfProcessor.getDocument(commands, PageSize.A4);
-
- // String pngFile = MessageFormat.format(
- // "{0}_{1,number,0}x{2,number,0}_transparent.{3}", coordFile,
- // windowSizes[0], windowSizes[1], ext);
-
- // System.out.println("Preparing " + pngFile + "...");
- // try {
- // doc.writeTo(new FileOutputStream(pngFile));
- // } catch (Exception e) {
- // System.out.println("Could not write vector graphics");
- // }
-
- // System.out.println("Done.");
- // }
-
-
- // } catch (IOException e) {
- // System.out.println(MessageFormat.format(
- // "Error processing {0}:\n{1}", e.getMessage()));
- // }
- // }
- }
-
- private static void generateTransparent(boolean loadedEdgeColors, int[] windowSizes, List coordFiles,
- ViewerIO verterIO) {
- System.out.println("Going for transparent");
- // Lets process coords files
- for (String coordFile : coordFiles) {
- try {
- System.out.println("Loading " + coordFile + "...");
- verterIO.loadVertexCoords(new File(coordFile));
-
- String pngFile = MessageFormat.format(
- "{0}_{1,number,0}x{2,number,0}_transparent.png", coordFile,
- windowSizes[0], windowSizes[1]);
- System.out.println("Preparing " + pngFile + "...");
- FormatVertex formatter = new FormatVertex(
- verterIO.getVertices(), verterIO.getStats(),
- windowSizes, 1);
-
- EdgesPanel panel = new EdgesPanel(verterIO.getEdges(),
- verterIO.getVertices(), windowSizes[0], windowSizes[1]);
-
- if (loadedEdgeColors)
- panel.addEdgeColors(verterIO.getEdgeColorMap());
-
- panel.showVertices(true);
- panel.setVisibilityTest(true);
- panel.setFormatter(formatter);
- panel.setEdgeColor(EDGE_COLOR);
- panel.setVertexColor(Color.white);
- panel.setBackgroundColor(new Color(0f,0f,0f,0f));
-
- BufferedImage bufferedImage = new BufferedImage(windowSizes[0],
- windowSizes[1], BufferedImage.TYPE_INT_ARGB);
-
- // Now the image has to be fitted to the given region
- panel.fitData();
- panel.writeImage(pngFile, bufferedImage);
- System.out.println("Done.");
- } catch (IOException e) {
- System.out.println(MessageFormat.format(
- "Error processing {0}:\n{1}", e.getMessage()));
- }
- }
- }
-
- private static void generateLight(boolean loadedEdgeColors, int[] windowSizes, List coordFiles,
- ViewerIO verterIO) {
- System.out.println("Going for light");
- // Lets process coords files
- for (String coordFile : coordFiles) {
- try {
- System.out.println("Loading " + coordFile + "...");
- verterIO.loadVertexCoords(new File(coordFile));
-
- String pngFile = MessageFormat.format(
- "{0}_{1,number,0}x{2,number,0}_light.png", coordFile,
- windowSizes[0], windowSizes[1]);
- System.out.println("Preparing " + pngFile + "...");
- FormatVertex formatter = new FormatVertex(
- verterIO.getVertices(), verterIO.getStats(),
- windowSizes, 1);
-
- EdgesPanel panel = new EdgesPanel(verterIO.getEdges(),
- verterIO.getVertices(), windowSizes[0], windowSizes[1]);
-
- if (loadedEdgeColors)
- panel.addEdgeColors(verterIO.getEdgeColorMap());
-
- panel.showVertices(true);
- panel.setVisibilityTest(true);
- panel.setFormatter(formatter);
- panel.setEdgeColor(EDGE_COLOR);
- panel.setVertexColor(Color.white);
- panel.setBackgroundColor(Color.white);
-
- BufferedImage bufferedImage = new BufferedImage(windowSizes[0],
- windowSizes[1], BufferedImage.TYPE_INT_ARGB);
-
- // Now the image has to be fitted to the given region
- panel.fitData();
- panel.writeImage(pngFile, bufferedImage);
- System.out.println("Done.");
- } catch (IOException e) {
- System.out.println(MessageFormat.format(
- "Error processing {0}:\n{1}", e.getMessage()));
- }
- }
- }
-
- private static void generateDark(boolean loadedEdgeColors, int[] windowSizes, List coordFiles,
- ViewerIO verterIO) {
- System.out.println("Going for dark");
- // Lets process coords files
- for (String coordFile : coordFiles) {
- try {
- System.out.println("Loading " + coordFile + "...");
- verterIO.loadVertexCoords(new File(coordFile));
-
- String pngFile = MessageFormat.format(
- "{0}_{1,number,0}x{2,number,0}_dark.png", coordFile,
- windowSizes[0], windowSizes[1]);
- System.out.println("Preparing " + pngFile + "...");
- FormatVertex formatter = new FormatVertex(
- verterIO.getVertices(), verterIO.getStats(),
- windowSizes, 1);
-
- EdgesPanel panel = new EdgesPanel(verterIO.getEdges(),
- verterIO.getVertices(), windowSizes[0], windowSizes[1]);
-
- if (loadedEdgeColors)
- panel.addEdgeColors(verterIO.getEdgeColorMap());
-
- panel.showVertices(true);
- panel.setVisibilityTest(true);
- panel.setFormatter(formatter);
- panel.setEdgeColor(EDGE_COLOR);
- panel.setVertexColor(Color.white);
- panel.setBackgroundColor(Color.BLACK);
-
- BufferedImage bufferedImage = new BufferedImage(windowSizes[0],
- windowSizes[1], BufferedImage.TYPE_INT_ARGB);
-
- // Now the image has to be fitted to the given region
- panel.fitData();
- panel.writeImage(pngFile, bufferedImage);
- System.out.println("Done.");
- } catch (IOException e) {
- System.out.println(MessageFormat.format(
- "Error processing {0}:\n{1}", e.getMessage()));
- }
- }
- }
-
- public static void message() {
- System.out
- .println("Arguments:\n\n"
- + "\t... [-c ]\n\n"
- + "If no colors file specified program will try to load file named \""
- + EDGE_COLOR_FILE + "\".\n"
- + "By default edges are white. flindeberg mod");
- System.exit(1);
- }
-
-}
+package ImageMaker;
+
+import java.awt.Color;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+import Viewer2D.EdgesPanel;
+import Viewer2D.FormatVertex;
+import Viewer2D.ViewerIO;
+
+public class GenerateImages {
+
+ public static boolean GENERATE_IN_SEPARATE_THREAD = true;
+
+ /**
+ * Entry point.
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ ParseArguments pa = new ParseArguments(false);
+ pa.parse(args);
+
+ printStats(pa);
+
+ GENERATE_IN_SEPARATE_THREAD = true;
+
+ generate(pa, "dark with labels", "dark_withlabels", Color.BLACK,
+ true /*scale*/, true /*printLabels*/, true /*useAlignmentCenterArg*/);
+ generate(pa, "dark without labels", "dark_nolabels", Color.BLACK,
+ true /*scale*/, false /*printLabels*/, true /*useAlignmentCenterArg*/);
+
+ generate(pa, "dark without scale without labels", "dark_withoutscale_withoutlabels", Color.BLACK,
+ false /*scale*/, false /*printLabels*/, false /*useAlignmentCenterArg*/);
+ generate(pa, "dark without scale with labels", "dark_withoutscale_withlabels", Color.BLACK,
+ false /*scale*/, true /*printLabels*/, false /*useAlignmentCenterArg*/);
+
+ generate(pa, "light without scale without labels", "light_withoutscale_withoutlabels", Color.WHITE,
+ false /*scale*/, false /*printLabels*/, false /*useAlignmentCenterArg*/);
+ generate(pa, "transparent without scale without labels", "transparent_withoutscale_withoutlabels", new Color(0f, 0f, 0f, 0f),
+ false /*scale*/, false /*printLabels*/, false /*useAlignmentCenterArg*/);
+ }
+
+ private static void printStats(ParseArguments pa) {
+ try {
+ ViewerIO v = createViewerIO(pa);
+ v.loadVertexCoords(new File(pa.coordFiles.get(0)));
+ v.getStats().print();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static ViewerIO createViewerIO(ParseArguments pa) {
+ ViewerIO verterIO = null;
+ try {
+ verterIO = new ViewerIO(new File(pa.edgeFile));
+ verterIO.loadSHORTFile();
+ } catch (IOException e) {
+ System.out.println(e.getMessage());
+ System.exit(1);
+ }
+ verterIO.setLabelScale(pa.scaling);
+
+ verterIO.setMinMaxXY(pa.minX, pa.minY, pa.maxX, pa.maxY);
+
+ try {
+ verterIO.loadEdgeColorFile(new File(pa.edgeColorFile));
+ } catch (java.io.FileNotFoundException e) {
+ System.out.println(e.getMessage());
+ } catch (java.io.IOException e) {
+ System.out.println(e.getMessage());
+ System.exit(1);
+ }
+
+ return verterIO;
+ }
+
+ private static void generate(ParseArguments pa, String displayname, String name, Color background,
+ boolean scale, boolean printLabels, boolean useAlignmentCenterArg) {
+
+ ViewerIO verterIO = createViewerIO(pa);
+
+ Runnable task = new Runnable() {
+ @Override
+ public void run() {
+ generate(displayname, name, background, !verterIO.getEdgeColorMap().isEmpty(), pa.windowSizes, pa.coordFiles,
+ printLabels ? pa.labelFile : "", useAlignmentCenterArg ? pa.alignmentCenter : false, verterIO, scale);
+ }
+ };
+
+ if (GENERATE_IN_SEPARATE_THREAD) {
+ new Thread(task).start();
+ }
+ else {
+ task.run();
+ }
+ }
+
+ private static void generate(String displayname, String name, Color background, boolean loadedEdgeColors,
+ int[] windowSizes, List coordFiles, String labelFile, boolean alignmentCenter, ViewerIO verterIO, boolean scale) {
+ if (!labelFile.isEmpty())
+ loadLabels(labelFile, verterIO);
+ else
+ verterIO.clearLabels();
+
+ for (String coordFile : coordFiles) {
+ try {
+ verterIO.loadVertexCoords(new File(coordFile));
+
+ FormatVertex formatter = new FormatVertex(verterIO.getVertices(), verterIO.getLabels(),
+ verterIO.getLabelScale(), scale ? verterIO.getMinX() : 0, scale ? verterIO.getMinY() : 0,
+ scale ? verterIO.getMaxX() : 0, scale ? verterIO.getMaxY() : 0, alignmentCenter,
+ verterIO.getStats(), windowSizes, 1);
+
+ EdgesPanel panel = new EdgesPanel(verterIO.getEdges(), verterIO.getVertices(), verterIO.getLabels(),
+ windowSizes[0], windowSizes[1]);
+
+ if (loadedEdgeColors)
+ panel.addEdgeColors(verterIO.getEdgeColorMap());
+
+ panel.showVertices(true);
+ panel.setVisibilityTest(true);
+ panel.setFormatter(formatter);
+ panel.setEdgeColor(EDGE_COLOR);
+ panel.setVertexColor(Color.white);
+ panel.setBackgroundColor(background);
+
+ BufferedImage bufferedImage = new BufferedImage(windowSizes[0], windowSizes[1],
+ BufferedImage.TYPE_INT_ARGB);
+
+ // Now the image has to be fitted to the given region
+ panel.fitData();
+ String pngFile = MessageFormat.format("{0}_{1,number,0}x{2,number,0}_" + name + ".png", coordFile,
+ windowSizes[0], windowSizes[1]);
+ panel.writeImage(pngFile, bufferedImage);
+ System.out.println("Done.");
+ } catch (IOException e) {
+ System.out.println(MessageFormat.format("Error processing {0}:\n{1}", e.getMessage()));
+ }
+ }
+ }
+
+ static void loadLabels(String labelFile, ViewerIO verterIO) {
+ if (labelFile.isEmpty()) return;
+ System.out.println("Loading label file: " + labelFile + "...");
+ try {
+ verterIO.loadLabelFile(new File(labelFile));
+ } catch (FileNotFoundException e) {
+ System.out.println(e.getMessage());
+ } catch (IOException e) {
+ System.out.println(e.getMessage());
+ System.exit(1);
+ }
+ System.out.println("Labels loading complete.");
+ }
+
+ public static class ParseArguments {
+
+ public String edgeFile;
+ public String edgeColorFile;
+ public String labelFile;
+ public double scaling;
+ public double minX;
+ public double maxX;
+ public double minY;
+ public double maxY;
+ int[] windowSizes;
+ boolean alignmentCenter;
+ public List coordFiles;
+ private boolean viewer2d;
+
+ public ParseArguments(boolean viewer2d) {
+ this.viewer2d = viewer2d;
+
+ }
+
+ void usage() {
+ if (viewer2d)
+ message2();
+ else
+ message();
+
+ }
+
+ public void parse(String[] args) {
+ int minArguments = 3;
+
+ if (viewer2d) {
+ minArguments = 1;
+ if (args.length == 0)
+ return;
+ }
+
+ if (args.length < minArguments) {
+ usage();
+ }
+ int argno = 0;
+ if (!viewer2d) {
+ windowSizes = new int[2];
+ windowSizes[0] = Integer.parseInt(args[0]);
+ windowSizes[1] = Integer.parseInt(args[1]);
+ argno += 2;
+ System.out.println("Image size is " + windowSizes[0] + " x " + windowSizes[1]);
+ }
+
+ // Check params
+ edgeFile = args[argno++];
+ edgeColorFile = "";
+ coordFiles = new ArrayList();
+ labelFile = "";
+ boolean colorFileSwitch = false;
+ boolean labelFileSwitch = false;
+ boolean scaleSwitch = false;
+ scaling = 1;
+
+ boolean wasMin = false;
+ boolean wasMax = false;
+ boolean minSwitch = false;
+ boolean maxSwitch = false;
+ minX = 0;
+ maxX = 0;
+ minY = 0;
+ maxY = 0;
+
+ alignmentCenter = false;
+ boolean alignSwitch = false;
+ for (int i = argno; i < args.length; i++) {
+ String arg = args[i];
+ if ("-c".equals(arg)) {
+ colorFileSwitch = true;
+ continue;
+ }
+ if ("-l".equals(arg)) {
+ labelFileSwitch = true;
+ continue;
+ }
+ if ("-s".equals(arg)) {
+ scaleSwitch = true;
+ continue;
+ }
+ if ("-m".equals(arg) && !viewer2d) {
+ minSwitch = true;
+ continue;
+ }
+ if ("-a".equals(arg) && !viewer2d) {
+ alignSwitch = true;
+ continue;
+ }
+ if ("-M".equals(arg) && !viewer2d) {
+ maxSwitch = true;
+ continue;
+ }
+ if (scaleSwitch) {
+ scaleSwitch = false;
+ scaling = Double.parseDouble(arg);
+ continue;
+ }
+ if (minSwitch) {
+ minSwitch = false;
+ wasMin = true;
+ String[] a = arg.split(",");
+ if (a.length != 2) {
+ System.out.println("Error:-m requires exactly 2 coordinates");
+ System.exit(1);
+
+ }
+ minX = Double.parseDouble(a[0]);
+ minY = Double.parseDouble(a[1]);
+ continue;
+ }
+ if (maxSwitch) {
+ maxSwitch = false;
+ wasMax = true;
+ String[] a = arg.split(",");
+ if (a.length != 2) {
+ System.out.println("Error:-M requires exactly 2 coordinates");
+ System.exit(1);
+ }
+ maxX = Double.parseDouble(a[0]);
+ maxY = Double.parseDouble(a[1]);
+ continue;
+ }
+ if (alignSwitch) {
+ alignSwitch = false;
+ if (arg.equals("center"))
+ alignmentCenter = true;
+ continue;
+ }
+ if (labelFileSwitch) {
+ labelFile = arg;
+ labelFileSwitch = false;
+
+ continue;
+ }
+ if (colorFileSwitch) {
+ edgeColorFile = arg;
+ colorFileSwitch = false;
+ continue;
+ }
+ coordFiles.add(arg);
+ }
+ if (coordFiles.isEmpty()) {
+ usage();
+ }
+
+ if (wasMax ^ wasMin) {
+ System.out.println("Error:Both -m and -M need to be used at the same time, one of them is missing");
+ System.exit(1);
+ }
+ }
+ }
+
+ public static Color EDGE_COLOR = Color.white;
+ public static String EDGE_COLOR_FILE = "color_file";
+
+ public static void message() {
+ System.out.println("Arguments:\n\n"
+ + "\t... [-c ] [-l ] [-m minx,miny -M -maxx,maxy] [-a center]\n\n"
+ + "If no colors file specified program will try to load file named \"" + EDGE_COLOR_FILE + "\".\n"
+ + "By default edges are white. flindeberg mod");
+ System.exit(1);
+ }
+
+ public static void message2() {
+ System.out.println("Arguments:\n\n" + "\t [-c ] [-l ]\n\n"
+ + "If no colors file specified program will try to load file named \"" + EDGE_COLOR_FILE + "\".\n");
+ System.exit(1);
+ }
+}
\ No newline at end of file
diff --git a/Java/src/Jama/ChangeLog b/Java/src/Jama/ChangeLog
new file mode 100644
index 00000000..1557c282
--- /dev/null
+++ b/Java/src/Jama/ChangeLog
@@ -0,0 +1,42 @@
+2012-11-09 Bruce Miller
+ * Version 1.0.3 Released.
+ * Patched hqr2 method in Jama.EigenvalueDecomposition
+ to avoid infinite loop;
+ Thanks Frederic Devernay
+ * Updated unchecked type coding in Matrix read.
+ * Added serialization ID to Jama.Matrix and Decomposition classes.
+ * Cleaned up javadoc documentation to Jama.Matrix and Decomposition classes.
+2005-07-13 Bruce Miller
+ * Version 1.0.2 Released.
+
+2005-07-12 Bruce Miller
+ * Although SVD sometimes fails on cases m < n,
+ the test code, apparently successfully, invokes
+ SVD to compute rank on an m
+ * Version 1.0.1 Released.
+
+2000-09-11 Bruce Miller
+ * Jama.Matrix print methods which create a NumberFormat, now set its
+ Locale to US so that the reader will recognize them even when the
+ default locale is not US. Similar change to Jama.test.TestMatrix.
+ (Thanks Ulrich Eberhardinger )
+
+1998-08-05 The Jama Team
+ * Initial Version released (1.0.0)
+
diff --git a/Java/src/Jama/CholeskyDecomposition.java b/Java/src/Jama/CholeskyDecomposition.java
new file mode 100644
index 00000000..57f4ccfb
--- /dev/null
+++ b/Java/src/Jama/CholeskyDecomposition.java
@@ -0,0 +1,201 @@
+package Jama;
+
+ /** Cholesky Decomposition.
+
+ For a symmetric, positive definite matrix A, the Cholesky decomposition
+ is an lower triangular matrix L so that A = L*L'.
+
+ If the matrix is not symmetric or positive definite, the constructor
+ returns a partial decomposition and sets an internal flag that may
+ be queried by the isSPD() method.
+ */
+
+public class CholeskyDecomposition implements java.io.Serializable {
+
+/* ------------------------
+ Class variables
+ * ------------------------ */
+
+ /** Array for internal storage of decomposition.
+ @serial internal array storage.
+ */
+ private double[][] L;
+
+ /** Row and column dimension (square matrix).
+ @serial matrix dimension.
+ */
+ private int n;
+
+ /** Symmetric and positive definite flag.
+ @serial is symmetric and positive definite flag.
+ */
+ private boolean isspd;
+
+/* ------------------------
+ Constructor
+ * ------------------------ */
+
+ /** Cholesky algorithm for symmetric and positive definite matrix.
+ Structure to access L and isspd flag.
+ @param Arg Square, symmetric matrix.
+ */
+
+ public CholeskyDecomposition (Matrix Arg) {
+
+
+ // Initialize.
+ double[][] A = Arg.getArray();
+ n = Arg.getRowDimension();
+ L = new double[n][n];
+ isspd = (Arg.getColumnDimension() == n);
+ // Main loop.
+ for (int j = 0; j < n; j++) {
+ double[] Lrowj = L[j];
+ double d = 0.0;
+ for (int k = 0; k < j; k++) {
+ double[] Lrowk = L[k];
+ double s = 0.0;
+ for (int i = 0; i < k; i++) {
+ s += Lrowk[i]*Lrowj[i];
+ }
+ Lrowj[k] = s = (A[j][k] - s)/L[k][k];
+ d = d + s*s;
+ isspd = isspd & (A[k][j] == A[j][k]);
+ }
+ d = A[j][j] - d;
+ isspd = isspd & (d > 0.0);
+ L[j][j] = Math.sqrt(Math.max(d,0.0));
+ for (int k = j+1; k < n; k++) {
+ L[j][k] = 0.0;
+ }
+ }
+ }
+
+/* ------------------------
+ Temporary, experimental code.
+ * ------------------------ *\
+
+ \** Right Triangular Cholesky Decomposition.
+
+ For a symmetric, positive definite matrix A, the Right Cholesky
+ decomposition is an upper triangular matrix R so that A = R'*R.
+ This constructor computes R with the Fortran inspired column oriented
+ algorithm used in LINPACK and MATLAB. In Java, we suspect a row oriented,
+ lower triangular decomposition is faster. We have temporarily included
+ this constructor here until timing experiments confirm this suspicion.
+ *\
+
+ \** Array for internal storage of right triangular decomposition. **\
+ private transient double[][] R;
+
+ \** Cholesky algorithm for symmetric and positive definite matrix.
+ @param A Square, symmetric matrix.
+ @param rightflag Actual value ignored.
+ @return Structure to access R and isspd flag.
+ *\
+
+ public CholeskyDecomposition (Matrix Arg, int rightflag) {
+ // Initialize.
+ double[][] A = Arg.getArray();
+ n = Arg.getColumnDimension();
+ R = new double[n][n];
+ isspd = (Arg.getColumnDimension() == n);
+ // Main loop.
+ for (int j = 0; j < n; j++) {
+ double d = 0.0;
+ for (int k = 0; k < j; k++) {
+ double s = A[k][j];
+ for (int i = 0; i < k; i++) {
+ s = s - R[i][k]*R[i][j];
+ }
+ R[k][j] = s = s/R[k][k];
+ d = d + s*s;
+ isspd = isspd & (A[k][j] == A[j][k]);
+ }
+ d = A[j][j] - d;
+ isspd = isspd & (d > 0.0);
+ R[j][j] = Math.sqrt(Math.max(d,0.0));
+ for (int k = j+1; k < n; k++) {
+ R[k][j] = 0.0;
+ }
+ }
+ }
+
+ \** Return upper triangular factor.
+ @return R
+ *\
+
+ public Matrix getR () {
+ return new Matrix(R,n,n);
+ }
+
+\* ------------------------
+ End of temporary code.
+ * ------------------------ */
+
+/* ------------------------
+ Public Methods
+ * ------------------------ */
+
+ /** Is the matrix symmetric and positive definite?
+ @return true if A is symmetric and positive definite.
+ */
+
+ public boolean isSPD () {
+ return isspd;
+ }
+
+ /** Return triangular factor.
+ @return L
+ */
+
+ public Matrix getL () {
+ return new Matrix(L,n,n);
+ }
+
+ /** Solve A*X = B
+ @param B A Matrix with as many rows as A and any number of columns.
+ @return X so that L*L'*X = B
+ @exception IllegalArgumentException Matrix row dimensions must agree.
+ @exception RuntimeException Matrix is not symmetric positive definite.
+ */
+
+ public Matrix solve (Matrix B) {
+ if (B.getRowDimension() != n) {
+ throw new IllegalArgumentException("Matrix row dimensions must agree.");
+ }
+ if (!isspd) {
+ throw new RuntimeException("Matrix is not symmetric positive definite.");
+ }
+
+ // Copy right hand side.
+ double[][] X = B.getArrayCopy();
+ int nx = B.getColumnDimension();
+
+ // Solve L*Y = B;
+ for (int k = 0; k < n; k++) {
+ for (int j = 0; j < nx; j++) {
+ for (int i = 0; i < k ; i++) {
+ X[k][j] -= X[i][j]*L[k][i];
+ }
+ X[k][j] /= L[k][k];
+ }
+ }
+
+ // Solve L'*X = Y;
+ for (int k = n-1; k >= 0; k--) {
+ for (int j = 0; j < nx; j++) {
+ for (int i = k+1; i < n ; i++) {
+ X[k][j] -= X[i][j]*L[i][k];
+ }
+ X[k][j] /= L[k][k];
+ }
+ }
+
+
+ return new Matrix(X,n,nx);
+ }
+ private static final long serialVersionUID = 1;
+
+}
+
diff --git a/Java/src/Jama/EigenvalueDecomposition.java b/Java/src/Jama/EigenvalueDecomposition.java
new file mode 100644
index 00000000..6657c3fa
--- /dev/null
+++ b/Java/src/Jama/EigenvalueDecomposition.java
@@ -0,0 +1,956 @@
+package Jama;
+import Jama.util.*;
+
+/** Eigenvalues and eigenvectors of a real matrix.
+
+ If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is
+ diagonal and the eigenvector matrix V is orthogonal.
+ I.e. A = V.times(D.times(V.transpose())) and
+ V.times(V.transpose()) equals the identity matrix.
+
+ If A is not symmetric, then the eigenvalue matrix D is block diagonal
+ with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
+ lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The
+ columns of V represent the eigenvectors in the sense that A*V = V*D,
+ i.e. A.times(V) equals V.times(D). The matrix V may be badly
+ conditioned, or even singular, so the validity of the equation
+ A = V*D*inverse(V) depends upon V.cond().
+**/
+
+public class EigenvalueDecomposition implements java.io.Serializable {
+
+/* ------------------------
+ Class variables
+ * ------------------------ */
+
+ /** Row and column dimension (square matrix).
+ @serial matrix dimension.
+ */
+ private int n;
+
+ /** Symmetry flag.
+ @serial internal symmetry flag.
+ */
+ private boolean issymmetric;
+
+ /** Arrays for internal storage of eigenvalues.
+ @serial internal storage of eigenvalues.
+ */
+ private double[] d, e;
+
+ /** Array for internal storage of eigenvectors.
+ @serial internal storage of eigenvectors.
+ */
+ private double[][] V;
+
+ /** Array for internal storage of nonsymmetric Hessenberg form.
+ @serial internal storage of nonsymmetric Hessenberg form.
+ */
+ private double[][] H;
+
+ /** Working storage for nonsymmetric algorithm.
+ @serial working storage for nonsymmetric algorithm.
+ */
+ private double[] ort;
+
+/* ------------------------
+ Private Methods
+ * ------------------------ */
+
+ // Symmetric Householder reduction to tridiagonal form.
+
+ private void tred2 () {
+
+ // This is derived from the Algol procedures tred2 by
+ // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+ // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
+ // Fortran subroutine in EISPACK.
+
+ for (int j = 0; j < n; j++) {
+ d[j] = V[n-1][j];
+ }
+
+ // Householder reduction to tridiagonal form.
+
+ for (int i = n-1; i > 0; i--) {
+
+ // Scale to avoid under/overflow.
+
+ double scale = 0.0;
+ double h = 0.0;
+ for (int k = 0; k < i; k++) {
+ scale = scale + Math.abs(d[k]);
+ }
+ if (scale == 0.0) {
+ e[i] = d[i-1];
+ for (int j = 0; j < i; j++) {
+ d[j] = V[i-1][j];
+ V[i][j] = 0.0;
+ V[j][i] = 0.0;
+ }
+ } else {
+
+ // Generate Householder vector.
+
+ for (int k = 0; k < i; k++) {
+ d[k] /= scale;
+ h += d[k] * d[k];
+ }
+ double f = d[i-1];
+ double g = Math.sqrt(h);
+ if (f > 0) {
+ g = -g;
+ }
+ e[i] = scale * g;
+ h = h - f * g;
+ d[i-1] = f - g;
+ for (int j = 0; j < i; j++) {
+ e[j] = 0.0;
+ }
+
+ // Apply similarity transformation to remaining columns.
+
+ for (int j = 0; j < i; j++) {
+ f = d[j];
+ V[j][i] = f;
+ g = e[j] + V[j][j] * f;
+ for (int k = j+1; k <= i-1; k++) {
+ g += V[k][j] * d[k];
+ e[k] += V[k][j] * f;
+ }
+ e[j] = g;
+ }
+ f = 0.0;
+ for (int j = 0; j < i; j++) {
+ e[j] /= h;
+ f += e[j] * d[j];
+ }
+ double hh = f / (h + h);
+ for (int j = 0; j < i; j++) {
+ e[j] -= hh * d[j];
+ }
+ for (int j = 0; j < i; j++) {
+ f = d[j];
+ g = e[j];
+ for (int k = j; k <= i-1; k++) {
+ V[k][j] -= (f * e[k] + g * d[k]);
+ }
+ d[j] = V[i-1][j];
+ V[i][j] = 0.0;
+ }
+ }
+ d[i] = h;
+ }
+
+ // Accumulate transformations.
+
+ for (int i = 0; i < n-1; i++) {
+ V[n-1][i] = V[i][i];
+ V[i][i] = 1.0;
+ double h = d[i+1];
+ if (h != 0.0) {
+ for (int k = 0; k <= i; k++) {
+ d[k] = V[k][i+1] / h;
+ }
+ for (int j = 0; j <= i; j++) {
+ double g = 0.0;
+ for (int k = 0; k <= i; k++) {
+ g += V[k][i+1] * V[k][j];
+ }
+ for (int k = 0; k <= i; k++) {
+ V[k][j] -= g * d[k];
+ }
+ }
+ }
+ for (int k = 0; k <= i; k++) {
+ V[k][i+1] = 0.0;
+ }
+ }
+ for (int j = 0; j < n; j++) {
+ d[j] = V[n-1][j];
+ V[n-1][j] = 0.0;
+ }
+ V[n-1][n-1] = 1.0;
+ e[0] = 0.0;
+ }
+
+ // Symmetric tridiagonal QL algorithm.
+
+ private void tql2 () {
+
+ // This is derived from the Algol procedures tql2, by
+ // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+ // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
+ // Fortran subroutine in EISPACK.
+
+ for (int i = 1; i < n; i++) {
+ e[i-1] = e[i];
+ }
+ e[n-1] = 0.0;
+
+ double f = 0.0;
+ double tst1 = 0.0;
+ double eps = Math.pow(2.0,-52.0);
+ for (int l = 0; l < n; l++) {
+
+ // Find small subdiagonal element
+
+ tst1 = Math.max(tst1,Math.abs(d[l]) + Math.abs(e[l]));
+ int m = l;
+ while (m < n) {
+ if (Math.abs(e[m]) <= eps*tst1) {
+ break;
+ }
+ m++;
+ }
+
+ // If m == l, d[l] is an eigenvalue,
+ // otherwise, iterate.
+
+ if (m > l) {
+ int iter = 0;
+ do {
+ iter = iter + 1; // (Could check iteration count here.)
+
+ // Compute implicit shift
+
+ double g = d[l];
+ double p = (d[l+1] - g) / (2.0 * e[l]);
+ double r = Maths.hypot(p,1.0);
+ if (p < 0) {
+ r = -r;
+ }
+ d[l] = e[l] / (p + r);
+ d[l+1] = e[l] * (p + r);
+ double dl1 = d[l+1];
+ double h = g - d[l];
+ for (int i = l+2; i < n; i++) {
+ d[i] -= h;
+ }
+ f = f + h;
+
+ // Implicit QL transformation.
+
+ p = d[m];
+ double c = 1.0;
+ double c2 = c;
+ double c3 = c;
+ double el1 = e[l+1];
+ double s = 0.0;
+ double s2 = 0.0;
+ for (int i = m-1; i >= l; i--) {
+ c3 = c2;
+ c2 = c;
+ s2 = s;
+ g = c * e[i];
+ h = c * p;
+ r = Maths.hypot(p,e[i]);
+ e[i+1] = s * r;
+ s = e[i] / r;
+ c = p / r;
+ p = c * d[i] - s * g;
+ d[i+1] = h + s * (c * g + s * d[i]);
+
+ // Accumulate transformation.
+
+ for (int k = 0; k < n; k++) {
+ h = V[k][i+1];
+ V[k][i+1] = s * V[k][i] + c * h;
+ V[k][i] = c * V[k][i] - s * h;
+ }
+ }
+ p = -s * s2 * c3 * el1 * e[l] / dl1;
+ e[l] = s * p;
+ d[l] = c * p;
+
+ // Check for convergence.
+
+ } while (Math.abs(e[l]) > eps*tst1);
+ }
+ d[l] = d[l] + f;
+ e[l] = 0.0;
+ }
+
+ // Sort eigenvalues and corresponding vectors.
+
+ for (int i = 0; i < n-1; i++) {
+ int k = i;
+ double p = d[i];
+ for (int j = i+1; j < n; j++) {
+ if (d[j] < p) {
+ k = j;
+ p = d[j];
+ }
+ }
+ if (k != i) {
+ d[k] = d[i];
+ d[i] = p;
+ for (int j = 0; j < n; j++) {
+ p = V[j][i];
+ V[j][i] = V[j][k];
+ V[j][k] = p;
+ }
+ }
+ }
+ }
+
+ // Nonsymmetric reduction to Hessenberg form.
+
+ private void orthes () {
+
+ // This is derived from the Algol procedures orthes and ortran,
+ // by Martin and Wilkinson, Handbook for Auto. Comp.,
+ // Vol.ii-Linear Algebra, and the corresponding
+ // Fortran subroutines in EISPACK.
+
+ int low = 0;
+ int high = n-1;
+
+ for (int m = low+1; m <= high-1; m++) {
+
+ // Scale column.
+
+ double scale = 0.0;
+ for (int i = m; i <= high; i++) {
+ scale = scale + Math.abs(H[i][m-1]);
+ }
+ if (scale != 0.0) {
+
+ // Compute Householder transformation.
+
+ double h = 0.0;
+ for (int i = high; i >= m; i--) {
+ ort[i] = H[i][m-1]/scale;
+ h += ort[i] * ort[i];
+ }
+ double g = Math.sqrt(h);
+ if (ort[m] > 0) {
+ g = -g;
+ }
+ h = h - ort[m] * g;
+ ort[m] = ort[m] - g;
+
+ // Apply Householder similarity transformation
+ // H = (I-u*u'/h)*H*(I-u*u')/h)
+
+ for (int j = m; j < n; j++) {
+ double f = 0.0;
+ for (int i = high; i >= m; i--) {
+ f += ort[i]*H[i][j];
+ }
+ f = f/h;
+ for (int i = m; i <= high; i++) {
+ H[i][j] -= f*ort[i];
+ }
+ }
+
+ for (int i = 0; i <= high; i++) {
+ double f = 0.0;
+ for (int j = high; j >= m; j--) {
+ f += ort[j]*H[i][j];
+ }
+ f = f/h;
+ for (int j = m; j <= high; j++) {
+ H[i][j] -= f*ort[j];
+ }
+ }
+ ort[m] = scale*ort[m];
+ H[m][m-1] = scale*g;
+ }
+ }
+
+ // Accumulate transformations (Algol's ortran).
+
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ V[i][j] = (i == j ? 1.0 : 0.0);
+ }
+ }
+
+ for (int m = high-1; m >= low+1; m--) {
+ if (H[m][m-1] != 0.0) {
+ for (int i = m+1; i <= high; i++) {
+ ort[i] = H[i][m-1];
+ }
+ for (int j = m; j <= high; j++) {
+ double g = 0.0;
+ for (int i = m; i <= high; i++) {
+ g += ort[i] * V[i][j];
+ }
+ // Double division avoids possible underflow
+ g = (g / ort[m]) / H[m][m-1];
+ for (int i = m; i <= high; i++) {
+ V[i][j] += g * ort[i];
+ }
+ }
+ }
+ }
+ }
+
+
+ // Complex scalar division.
+
+ private transient double cdivr, cdivi;
+ private void cdiv(double xr, double xi, double yr, double yi) {
+ double r,d;
+ if (Math.abs(yr) > Math.abs(yi)) {
+ r = yi/yr;
+ d = yr + r*yi;
+ cdivr = (xr + r*xi)/d;
+ cdivi = (xi - r*xr)/d;
+ } else {
+ r = yr/yi;
+ d = yi + r*yr;
+ cdivr = (r*xr + xi)/d;
+ cdivi = (r*xi - xr)/d;
+ }
+ }
+
+
+ // Nonsymmetric reduction from Hessenberg to real Schur form.
+
+ private void hqr2 () {
+
+ // This is derived from the Algol procedure hqr2,
+ // by Martin and Wilkinson, Handbook for Auto. Comp.,
+ // Vol.ii-Linear Algebra, and the corresponding
+ // Fortran subroutine in EISPACK.
+
+ // Initialize
+
+ int nn = this.n;
+ int n = nn-1;
+ int low = 0;
+ int high = nn-1;
+ double eps = Math.pow(2.0,-52.0);
+ double exshift = 0.0;
+ double p=0,q=0,r=0,s=0,z=0,t,w,x,y;
+
+ // Store roots isolated by balanc and compute matrix norm
+
+ double norm = 0.0;
+ for (int i = 0; i < nn; i++) {
+ if (i < low | i > high) {
+ d[i] = H[i][i];
+ e[i] = 0.0;
+ }
+ for (int j = Math.max(i-1,0); j < nn; j++) {
+ norm = norm + Math.abs(H[i][j]);
+ }
+ }
+
+ // Outer loop over eigenvalue index
+
+ int iter = 0;
+ while (n >= low) {
+
+ // Look for single small sub-diagonal element
+
+ int l = n;
+ while (l > low) {
+ s = Math.abs(H[l-1][l-1]) + Math.abs(H[l][l]);
+ if (s == 0.0) {
+ s = norm;
+ }
+ if (Math.abs(H[l][l-1]) < eps * s) {
+ break;
+ }
+ l--;
+ }
+
+ // Check for convergence
+ // One root found
+
+ if (l == n) {
+ H[n][n] = H[n][n] + exshift;
+ d[n] = H[n][n];
+ e[n] = 0.0;
+ n--;
+ iter = 0;
+
+ // Two roots found
+
+ } else if (l == n-1) {
+ w = H[n][n-1] * H[n-1][n];
+ p = (H[n-1][n-1] - H[n][n]) / 2.0;
+ q = p * p + w;
+ z = Math.sqrt(Math.abs(q));
+ H[n][n] = H[n][n] + exshift;
+ H[n-1][n-1] = H[n-1][n-1] + exshift;
+ x = H[n][n];
+
+ // Real pair
+
+ if (q >= 0) {
+ if (p >= 0) {
+ z = p + z;
+ } else {
+ z = p - z;
+ }
+ d[n-1] = x + z;
+ d[n] = d[n-1];
+ if (z != 0.0) {
+ d[n] = x - w / z;
+ }
+ e[n-1] = 0.0;
+ e[n] = 0.0;
+ x = H[n][n-1];
+ s = Math.abs(x) + Math.abs(z);
+ p = x / s;
+ q = z / s;
+ r = Math.sqrt(p * p+q * q);
+ p = p / r;
+ q = q / r;
+
+ // Row modification
+
+ for (int j = n-1; j < nn; j++) {
+ z = H[n-1][j];
+ H[n-1][j] = q * z + p * H[n][j];
+ H[n][j] = q * H[n][j] - p * z;
+ }
+
+ // Column modification
+
+ for (int i = 0; i <= n; i++) {
+ z = H[i][n-1];
+ H[i][n-1] = q * z + p * H[i][n];
+ H[i][n] = q * H[i][n] - p * z;
+ }
+
+ // Accumulate transformations
+
+ for (int i = low; i <= high; i++) {
+ z = V[i][n-1];
+ V[i][n-1] = q * z + p * V[i][n];
+ V[i][n] = q * V[i][n] - p * z;
+ }
+
+ // Complex pair
+
+ } else {
+ d[n-1] = x + p;
+ d[n] = x + p;
+ e[n-1] = z;
+ e[n] = -z;
+ }
+ n = n - 2;
+ iter = 0;
+
+ // No convergence yet
+
+ } else {
+
+ // Form shift
+
+ x = H[n][n];
+ y = 0.0;
+ w = 0.0;
+ if (l < n) {
+ y = H[n-1][n-1];
+ w = H[n][n-1] * H[n-1][n];
+ }
+
+ // Wilkinson's original ad hoc shift
+
+ if (iter == 10) {
+ exshift += x;
+ for (int i = low; i <= n; i++) {
+ H[i][i] -= x;
+ }
+ s = Math.abs(H[n][n-1]) + Math.abs(H[n-1][n-2]);
+ x = y = 0.75 * s;
+ w = -0.4375 * s * s;
+ }
+
+ // MATLAB's new ad hoc shift
+
+ if (iter == 30) {
+ s = (y - x) / 2.0;
+ s = s * s + w;
+ if (s > 0) {
+ s = Math.sqrt(s);
+ if (y < x) {
+ s = -s;
+ }
+ s = x - w / ((y - x) / 2.0 + s);
+ for (int i = low; i <= n; i++) {
+ H[i][i] -= s;
+ }
+ exshift += s;
+ x = y = w = 0.964;
+ }
+ }
+
+ iter = iter + 1; // (Could check iteration count here.)
+
+ // Look for two consecutive small sub-diagonal elements
+
+ int m = n-2;
+ while (m >= l) {
+ z = H[m][m];
+ r = x - z;
+ s = y - z;
+ p = (r * s - w) / H[m+1][m] + H[m][m+1];
+ q = H[m+1][m+1] - z - r - s;
+ r = H[m+2][m+1];
+ s = Math.abs(p) + Math.abs(q) + Math.abs(r);
+ p = p / s;
+ q = q / s;
+ r = r / s;
+ if (m == l) {
+ break;
+ }
+ if (Math.abs(H[m][m-1]) * (Math.abs(q) + Math.abs(r)) <
+ eps * (Math.abs(p) * (Math.abs(H[m-1][m-1]) + Math.abs(z) +
+ Math.abs(H[m+1][m+1])))) {
+ break;
+ }
+ m--;
+ }
+
+ for (int i = m+2; i <= n; i++) {
+ H[i][i-2] = 0.0;
+ if (i > m+2) {
+ H[i][i-3] = 0.0;
+ }
+ }
+
+ // Double QR step involving rows l:n and columns m:n
+
+
+ for (int k = m; k <= n-1; k++) {
+ boolean notlast = (k != n-1);
+ if (k != m) {
+ p = H[k][k-1];
+ q = H[k+1][k-1];
+ r = (notlast ? H[k+2][k-1] : 0.0);
+ x = Math.abs(p) + Math.abs(q) + Math.abs(r);
+ if (x == 0.0) {
+ continue;
+ }
+ p = p / x;
+ q = q / x;
+ r = r / x;
+ }
+
+ s = Math.sqrt(p * p + q * q + r * r);
+ if (p < 0) {
+ s = -s;
+ }
+ if (s != 0) {
+ if (k != m) {
+ H[k][k-1] = -s * x;
+ } else if (l != m) {
+ H[k][k-1] = -H[k][k-1];
+ }
+ p = p + s;
+ x = p / s;
+ y = q / s;
+ z = r / s;
+ q = q / p;
+ r = r / p;
+
+ // Row modification
+
+ for (int j = k; j < nn; j++) {
+ p = H[k][j] + q * H[k+1][j];
+ if (notlast) {
+ p = p + r * H[k+2][j];
+ H[k+2][j] = H[k+2][j] - p * z;
+ }
+ H[k][j] = H[k][j] - p * x;
+ H[k+1][j] = H[k+1][j] - p * y;
+ }
+
+ // Column modification
+
+ for (int i = 0; i <= Math.min(n,k+3); i++) {
+ p = x * H[i][k] + y * H[i][k+1];
+ if (notlast) {
+ p = p + z * H[i][k+2];
+ H[i][k+2] = H[i][k+2] - p * r;
+ }
+ H[i][k] = H[i][k] - p;
+ H[i][k+1] = H[i][k+1] - p * q;
+ }
+
+ // Accumulate transformations
+
+ for (int i = low; i <= high; i++) {
+ p = x * V[i][k] + y * V[i][k+1];
+ if (notlast) {
+ p = p + z * V[i][k+2];
+ V[i][k+2] = V[i][k+2] - p * r;
+ }
+ V[i][k] = V[i][k] - p;
+ V[i][k+1] = V[i][k+1] - p * q;
+ }
+ } // (s != 0)
+ } // k loop
+ } // check convergence
+ } // while (n >= low)
+
+ // Backsubstitute to find vectors of upper triangular form
+
+ if (norm == 0.0) {
+ return;
+ }
+
+ for (n = nn-1; n >= 0; n--) {
+ p = d[n];
+ q = e[n];
+
+ // Real vector
+
+ if (q == 0) {
+ int l = n;
+ H[n][n] = 1.0;
+ for (int i = n-1; i >= 0; i--) {
+ w = H[i][i] - p;
+ r = 0.0;
+ for (int j = l; j <= n; j++) {
+ r = r + H[i][j] * H[j][n];
+ }
+ if (e[i] < 0.0) {
+ z = w;
+ s = r;
+ } else {
+ l = i;
+ if (e[i] == 0.0) {
+ if (w != 0.0) {
+ H[i][n] = -r / w;
+ } else {
+ H[i][n] = -r / (eps * norm);
+ }
+
+ // Solve real equations
+
+ } else {
+ x = H[i][i+1];
+ y = H[i+1][i];
+ q = (d[i] - p) * (d[i] - p) + e[i] * e[i];
+ t = (x * s - z * r) / q;
+ H[i][n] = t;
+ if (Math.abs(x) > Math.abs(z)) {
+ H[i+1][n] = (-r - w * t) / x;
+ } else {
+ H[i+1][n] = (-s - y * t) / z;
+ }
+ }
+
+ // Overflow control
+
+ t = Math.abs(H[i][n]);
+ if ((eps * t) * t > 1) {
+ for (int j = i; j <= n; j++) {
+ H[j][n] = H[j][n] / t;
+ }
+ }
+ }
+ }
+
+ // Complex vector
+
+ } else if (q < 0) {
+ int l = n-1;
+
+ // Last vector component imaginary so matrix is triangular
+
+ if (Math.abs(H[n][n-1]) > Math.abs(H[n-1][n])) {
+ H[n-1][n-1] = q / H[n][n-1];
+ H[n-1][n] = -(H[n][n] - p) / H[n][n-1];
+ } else {
+ cdiv(0.0,-H[n-1][n],H[n-1][n-1]-p,q);
+ H[n-1][n-1] = cdivr;
+ H[n-1][n] = cdivi;
+ }
+ H[n][n-1] = 0.0;
+ H[n][n] = 1.0;
+ for (int i = n-2; i >= 0; i--) {
+ double ra,sa,vr,vi;
+ ra = 0.0;
+ sa = 0.0;
+ for (int j = l; j <= n; j++) {
+ ra = ra + H[i][j] * H[j][n-1];
+ sa = sa + H[i][j] * H[j][n];
+ }
+ w = H[i][i] - p;
+
+ if (e[i] < 0.0) {
+ z = w;
+ r = ra;
+ s = sa;
+ } else {
+ l = i;
+ if (e[i] == 0) {
+ cdiv(-ra,-sa,w,q);
+ H[i][n-1] = cdivr;
+ H[i][n] = cdivi;
+ } else {
+
+ // Solve complex equations
+
+ x = H[i][i+1];
+ y = H[i+1][i];
+ vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q;
+ vi = (d[i] - p) * 2.0 * q;
+ if (vr == 0.0 & vi == 0.0) {
+ vr = eps * norm * (Math.abs(w) + Math.abs(q) +
+ Math.abs(x) + Math.abs(y) + Math.abs(z));
+ }
+ cdiv(x*r-z*ra+q*sa,x*s-z*sa-q*ra,vr,vi);
+ H[i][n-1] = cdivr;
+ H[i][n] = cdivi;
+ if (Math.abs(x) > (Math.abs(z) + Math.abs(q))) {
+ H[i+1][n-1] = (-ra - w * H[i][n-1] + q * H[i][n]) / x;
+ H[i+1][n] = (-sa - w * H[i][n] - q * H[i][n-1]) / x;
+ } else {
+ cdiv(-r-y*H[i][n-1],-s-y*H[i][n],z,q);
+ H[i+1][n-1] = cdivr;
+ H[i+1][n] = cdivi;
+ }
+ }
+
+ // Overflow control
+
+ t = Math.max(Math.abs(H[i][n-1]),Math.abs(H[i][n]));
+ if ((eps * t) * t > 1) {
+ for (int j = i; j <= n; j++) {
+ H[j][n-1] = H[j][n-1] / t;
+ H[j][n] = H[j][n] / t;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Vectors of isolated roots
+
+ for (int i = 0; i < nn; i++) {
+ if (i < low | i > high) {
+ for (int j = i; j < nn; j++) {
+ V[i][j] = H[i][j];
+ }
+ }
+ }
+
+ // Back transformation to get eigenvectors of original matrix
+
+ for (int j = nn-1; j >= low; j--) {
+ for (int i = low; i <= high; i++) {
+ z = 0.0;
+ for (int k = low; k <= Math.min(j,high); k++) {
+ z = z + V[i][k] * H[k][j];
+ }
+ V[i][j] = z;
+ }
+ }
+ }
+
+
+/* ------------------------
+ Constructor
+ * ------------------------ */
+
+ /** Check for symmetry, then construct the eigenvalue decomposition
+ Structure to access D and V.
+ @param Arg Square matrix
+ */
+
+ public EigenvalueDecomposition (Matrix Arg) {
+ double[][] A = Arg.getArray();
+ n = Arg.getColumnDimension();
+ V = new double[n][n];
+ d = new double[n];
+ e = new double[n];
+
+ issymmetric = true;
+ for (int j = 0; (j < n) & issymmetric; j++) {
+ for (int i = 0; (i < n) & issymmetric; i++) {
+ issymmetric = (A[i][j] == A[j][i]);
+ }
+ }
+
+ if (issymmetric) {
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ V[i][j] = A[i][j];
+ }
+ }
+
+ // Tridiagonalize.
+ tred2();
+
+ // Diagonalize.
+ tql2();
+
+ } else {
+ H = new double[n][n];
+ ort = new double[n];
+
+ for (int j = 0; j < n; j++) {
+ for (int i = 0; i < n; i++) {
+ H[i][j] = A[i][j];
+ }
+ }
+
+ // Reduce to Hessenberg form.
+ orthes();
+
+ // Reduce Hessenberg to real Schur form.
+ hqr2();
+ }
+ }
+
+/* ------------------------
+ Public Methods
+ * ------------------------ */
+
+ /** Return the eigenvector matrix
+ @return V
+ */
+
+ public Matrix getV () {
+ return new Matrix(V,n,n);
+ }
+
+ /** Return the real parts of the eigenvalues
+ @return real(diag(D))
+ */
+
+ public double[] getRealEigenvalues () {
+ return d;
+ }
+
+ /** Return the imaginary parts of the eigenvalues
+ @return imag(diag(D))
+ */
+
+ public double[] getImagEigenvalues () {
+ return e;
+ }
+
+ /** Return the block diagonal eigenvalue matrix
+ @return D
+ */
+
+ public Matrix getD () {
+ Matrix X = new Matrix(n,n);
+ double[][] D = X.getArray();
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ D[i][j] = 0.0;
+ }
+ D[i][i] = d[i];
+ if (e[i] > 0) {
+ D[i][i+1] = e[i];
+ } else if (e[i] < 0) {
+ D[i][i-1] = e[i];
+ }
+ }
+ return X;
+ }
+ private static final long serialVersionUID = 1;
+}
diff --git a/Java/src/Jama/LUDecomposition.java b/Java/src/Jama/LUDecomposition.java
new file mode 100644
index 00000000..dc43dc78
--- /dev/null
+++ b/Java/src/Jama/LUDecomposition.java
@@ -0,0 +1,312 @@
+package Jama;
+
+ /** LU Decomposition.
+
+ For an m-by-n matrix A with m >= n, the LU decomposition is an m-by-n
+ unit lower triangular matrix L, an n-by-n upper triangular matrix U,
+ and a permutation vector piv of length m so that A(piv,:) = L*U.
+ If m < n, then L is m-by-m and U is m-by-n.
+
+ The LU decompostion with pivoting always exists, even if the matrix is
+ singular, so the constructor will never fail. The primary use of the
+ LU decomposition is in the solution of square systems of simultaneous
+ linear equations. This will fail if isNonsingular() returns false.
+ */
+
+public class LUDecomposition implements java.io.Serializable {
+
+/* ------------------------
+ Class variables
+ * ------------------------ */
+
+ /** Array for internal storage of decomposition.
+ @serial internal array storage.
+ */
+ private double[][] LU;
+
+ /** Row and column dimensions, and pivot sign.
+ @serial column dimension.
+ @serial row dimension.
+ @serial pivot sign.
+ */
+ private int m, n, pivsign;
+
+ /** Internal storage of pivot vector.
+ @serial pivot vector.
+ */
+ private int[] piv;
+
+/* ------------------------
+ Constructor
+ * ------------------------ */
+
+ /** LU Decomposition
+ Structure to access L, U and piv.
+ @param A Rectangular matrix
+ */
+
+ public LUDecomposition (Matrix A) {
+
+ // Use a "left-looking", dot-product, Crout/Doolittle algorithm.
+
+ LU = A.getArrayCopy();
+ m = A.getRowDimension();
+ n = A.getColumnDimension();
+ piv = new int[m];
+ for (int i = 0; i < m; i++) {
+ piv[i] = i;
+ }
+ pivsign = 1;
+ double[] LUrowi;
+ double[] LUcolj = new double[m];
+
+ // Outer loop.
+
+ for (int j = 0; j < n; j++) {
+
+ // Make a copy of the j-th column to localize references.
+
+ for (int i = 0; i < m; i++) {
+ LUcolj[i] = LU[i][j];
+ }
+
+ // Apply previous transformations.
+
+ for (int i = 0; i < m; i++) {
+ LUrowi = LU[i];
+
+ // Most of the time is spent in the following dot product.
+
+ int kmax = Math.min(i,j);
+ double s = 0.0;
+ for (int k = 0; k < kmax; k++) {
+ s += LUrowi[k]*LUcolj[k];
+ }
+
+ LUrowi[j] = LUcolj[i] -= s;
+ }
+
+ // Find pivot and exchange if necessary.
+
+ int p = j;
+ for (int i = j+1; i < m; i++) {
+ if (Math.abs(LUcolj[i]) > Math.abs(LUcolj[p])) {
+ p = i;
+ }
+ }
+ if (p != j) {
+ for (int k = 0; k < n; k++) {
+ double t = LU[p][k]; LU[p][k] = LU[j][k]; LU[j][k] = t;
+ }
+ int k = piv[p]; piv[p] = piv[j]; piv[j] = k;
+ pivsign = -pivsign;
+ }
+
+ // Compute multipliers.
+
+ if (j < m & LU[j][j] != 0.0) {
+ for (int i = j+1; i < m; i++) {
+ LU[i][j] /= LU[j][j];
+ }
+ }
+ }
+ }
+
+/* ------------------------
+ Temporary, experimental code.
+ ------------------------ *\
+
+ \** LU Decomposition, computed by Gaussian elimination.
+
+ This constructor computes L and U with the "daxpy"-based elimination
+ algorithm used in LINPACK and MATLAB. In Java, we suspect the dot-product,
+ Crout algorithm will be faster. We have temporarily included this
+ constructor until timing experiments confirm this suspicion.
+
+ @param A Rectangular matrix
+ @param linpackflag Use Gaussian elimination. Actual value ignored.
+ @return Structure to access L, U and piv.
+ *\
+
+ public LUDecomposition (Matrix A, int linpackflag) {
+ // Initialize.
+ LU = A.getArrayCopy();
+ m = A.getRowDimension();
+ n = A.getColumnDimension();
+ piv = new int[m];
+ for (int i = 0; i < m; i++) {
+ piv[i] = i;
+ }
+ pivsign = 1;
+ // Main loop.
+ for (int k = 0; k < n; k++) {
+ // Find pivot.
+ int p = k;
+ for (int i = k+1; i < m; i++) {
+ if (Math.abs(LU[i][k]) > Math.abs(LU[p][k])) {
+ p = i;
+ }
+ }
+ // Exchange if necessary.
+ if (p != k) {
+ for (int j = 0; j < n; j++) {
+ double t = LU[p][j]; LU[p][j] = LU[k][j]; LU[k][j] = t;
+ }
+ int t = piv[p]; piv[p] = piv[k]; piv[k] = t;
+ pivsign = -pivsign;
+ }
+ // Compute multipliers and eliminate k-th column.
+ if (LU[k][k] != 0.0) {
+ for (int i = k+1; i < m; i++) {
+ LU[i][k] /= LU[k][k];
+ for (int j = k+1; j < n; j++) {
+ LU[i][j] -= LU[i][k]*LU[k][j];
+ }
+ }
+ }
+ }
+ }
+
+\* ------------------------
+ End of temporary code.
+ * ------------------------ */
+
+/* ------------------------
+ Public Methods
+ * ------------------------ */
+
+ /** Is the matrix nonsingular?
+ @return true if U, and hence A, is nonsingular.
+ */
+
+ public boolean isNonsingular () {
+ for (int j = 0; j < n; j++) {
+ if (LU[j][j] == 0)
+ return false;
+ }
+ return true;
+ }
+
+ /** Return lower triangular factor
+ @return L
+ */
+
+ public Matrix getL () {
+ Matrix X = new Matrix(m,n);
+ double[][] L = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (i > j) {
+ L[i][j] = LU[i][j];
+ } else if (i == j) {
+ L[i][j] = 1.0;
+ } else {
+ L[i][j] = 0.0;
+ }
+ }
+ }
+ return X;
+ }
+
+ /** Return upper triangular factor
+ @return U
+ */
+
+ public Matrix getU () {
+ Matrix X = new Matrix(n,n);
+ double[][] U = X.getArray();
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ if (i <= j) {
+ U[i][j] = LU[i][j];
+ } else {
+ U[i][j] = 0.0;
+ }
+ }
+ }
+ return X;
+ }
+
+ /** Return pivot permutation vector
+ @return piv
+ */
+
+ public int[] getPivot () {
+ int[] p = new int[m];
+ for (int i = 0; i < m; i++) {
+ p[i] = piv[i];
+ }
+ return p;
+ }
+
+ /** Return pivot permutation vector as a one-dimensional double array
+ @return (double) piv
+ */
+
+ public double[] getDoublePivot () {
+ double[] vals = new double[m];
+ for (int i = 0; i < m; i++) {
+ vals[i] = (double) piv[i];
+ }
+ return vals;
+ }
+
+ /** Determinant
+ @return det(A)
+ @exception IllegalArgumentException Matrix must be square
+ */
+
+ public double det () {
+ if (m != n) {
+ throw new IllegalArgumentException("Matrix must be square.");
+ }
+ double d = (double) pivsign;
+ for (int j = 0; j < n; j++) {
+ d *= LU[j][j];
+ }
+ return d;
+ }
+
+ /** Solve A*X = B
+ @param B A Matrix with as many rows as A and any number of columns.
+ @return X so that L*U*X = B(piv,:)
+ @exception IllegalArgumentException Matrix row dimensions must agree.
+ @exception RuntimeException Matrix is singular.
+ */
+
+ public Matrix solve (Matrix B) {
+ if (B.getRowDimension() != m) {
+ throw new IllegalArgumentException("Matrix row dimensions must agree.");
+ }
+ if (!this.isNonsingular()) {
+ throw new RuntimeException("Matrix is singular.");
+ }
+
+ // Copy right hand side with pivoting
+ int nx = B.getColumnDimension();
+ Matrix Xmat = B.getMatrix(piv,0,nx-1);
+ double[][] X = Xmat.getArray();
+
+ // Solve L*Y = B(piv,:)
+ for (int k = 0; k < n; k++) {
+ for (int i = k+1; i < n; i++) {
+ for (int j = 0; j < nx; j++) {
+ X[i][j] -= X[k][j]*LU[i][k];
+ }
+ }
+ }
+ // Solve U*X = Y;
+ for (int k = n-1; k >= 0; k--) {
+ for (int j = 0; j < nx; j++) {
+ X[k][j] /= LU[k][k];
+ }
+ for (int i = 0; i < k; i++) {
+ for (int j = 0; j < nx; j++) {
+ X[i][j] -= X[k][j]*LU[i][k];
+ }
+ }
+ }
+ return Xmat;
+ }
+ private static final long serialVersionUID = 1;
+}
diff --git a/Java/src/Jama/Matrix.java b/Java/src/Jama/Matrix.java
new file mode 100644
index 00000000..8b113877
--- /dev/null
+++ b/Java/src/Jama/Matrix.java
@@ -0,0 +1,1046 @@
+package Jama;
+
+import java.text.NumberFormat;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.Locale;
+import java.text.FieldPosition;
+import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.StreamTokenizer;
+import Jama.util.*;
+
+/**
+ Jama = Java Matrix class.
+
+ The Java Matrix Class provides the fundamental operations of numerical
+ linear algebra. Various constructors create Matrices from two dimensional
+ arrays of double precision floating point numbers. Various "gets" and
+ "sets" provide access to submatrices and matrix elements. Several methods
+ implement basic matrix arithmetic, including matrix addition and
+ multiplication, matrix norms, and element-by-element array operations.
+ Methods for reading and printing matrices are also included. All the
+ operations in this version of the Matrix Class involve real matrices.
+ Complex matrices may be handled in a future version.
+
+ Five fundamental matrix decompositions, which consist of pairs or triples
+ of matrices, permutation vectors, and the like, produce results in five
+ decomposition classes. These decompositions are accessed by the Matrix
+ class to compute solutions of simultaneous linear equations, determinants,
+ inverses and other matrix functions. The five decompositions are:
+
+
Cholesky Decomposition of symmetric, positive definite matrices.
+
LU Decomposition of rectangular matrices.
+
QR Decomposition of rectangular matrices.
+
Singular Value Decomposition of rectangular matrices.
+
Eigenvalue Decomposition of both symmetric and nonsymmetric square matrices.
+
+
+
Example of use:
+
+
Solve a linear system A x = b and compute the residual norm, ||b - A x||.
+
+ double[][] vals = {{1.,2.,3},{4.,5.,6.},{7.,8.,10.}};
+ Matrix A = new Matrix(vals);
+ Matrix b = Matrix.random(3,1);
+ Matrix x = A.solve(b);
+ Matrix r = A.times(x).minus(b);
+ double rnorm = r.normInf();
+
+
+
+@author The MathWorks, Inc. and the National Institute of Standards and Technology.
+@version 5 August 1998
+*/
+
+public class Matrix implements Cloneable, java.io.Serializable {
+
+/* ------------------------
+ Class variables
+ * ------------------------ */
+
+ /** Array for internal storage of elements.
+ @serial internal array storage.
+ */
+ private double[][] A;
+
+ /** Row and column dimensions.
+ @serial row dimension.
+ @serial column dimension.
+ */
+ private int m, n;
+
+/* ------------------------
+ Constructors
+ * ------------------------ */
+
+ /** Construct an m-by-n matrix of zeros.
+ @param m Number of rows.
+ @param n Number of colums.
+ */
+
+ public Matrix (int m, int n) {
+ this.m = m;
+ this.n = n;
+ A = new double[m][n];
+ }
+
+ /** Construct an m-by-n constant matrix.
+ @param m Number of rows.
+ @param n Number of colums.
+ @param s Fill the matrix with this scalar value.
+ */
+
+ public Matrix (int m, int n, double s) {
+ this.m = m;
+ this.n = n;
+ A = new double[m][n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = s;
+ }
+ }
+ }
+
+ /** Construct a matrix from a 2-D array.
+ @param A Two-dimensional array of doubles.
+ @exception IllegalArgumentException All rows must have the same length
+ @see #constructWithCopy
+ */
+
+ public Matrix (double[][] A) {
+ m = A.length;
+ n = A[0].length;
+ for (int i = 0; i < m; i++) {
+ if (A[i].length != n) {
+ throw new IllegalArgumentException("All rows must have the same length.");
+ }
+ }
+ this.A = A;
+ }
+
+ /** Construct a matrix quickly without checking arguments.
+ @param A Two-dimensional array of doubles.
+ @param m Number of rows.
+ @param n Number of colums.
+ */
+
+ public Matrix (double[][] A, int m, int n) {
+ this.A = A;
+ this.m = m;
+ this.n = n;
+ }
+
+ /** Construct a matrix from a one-dimensional packed array
+ @param vals One-dimensional array of doubles, packed by columns (ala Fortran).
+ @param m Number of rows.
+ @exception IllegalArgumentException Array length must be a multiple of m.
+ */
+
+ public Matrix (double vals[], int m) {
+ this.m = m;
+ n = (m != 0 ? vals.length/m : 0);
+ if (m*n != vals.length) {
+ throw new IllegalArgumentException("Array length must be a multiple of m.");
+ }
+ A = new double[m][n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = vals[i+j*m];
+ }
+ }
+ }
+
+/* ------------------------
+ Public Methods
+ * ------------------------ */
+
+ /** Construct a matrix from a copy of a 2-D array.
+ @param A Two-dimensional array of doubles.
+ @exception IllegalArgumentException All rows must have the same length
+ */
+
+ public static Matrix constructWithCopy(double[][] A) {
+ int m = A.length;
+ int n = A[0].length;
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ if (A[i].length != n) {
+ throw new IllegalArgumentException
+ ("All rows must have the same length.");
+ }
+ for (int j = 0; j < n; j++) {
+ C[i][j] = A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** Make a deep copy of a matrix
+ */
+
+ public Matrix copy () {
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** Clone the Matrix object.
+ */
+
+ public Object clone () {
+ return this.copy();
+ }
+
+ /** Access the internal two-dimensional array.
+ @return Pointer to the two-dimensional array of matrix elements.
+ */
+
+ public double[][] getArray () {
+ return A;
+ }
+
+ /** Copy the internal two-dimensional array.
+ @return Two-dimensional array copy of matrix elements.
+ */
+
+ public double[][] getArrayCopy () {
+ double[][] C = new double[m][n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = A[i][j];
+ }
+ }
+ return C;
+ }
+
+ /** Make a one-dimensional column packed copy of the internal array.
+ @return Matrix elements packed in a one-dimensional array by columns.
+ */
+
+ public double[] getColumnPackedCopy () {
+ double[] vals = new double[m*n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ vals[i+j*m] = A[i][j];
+ }
+ }
+ return vals;
+ }
+
+ /** Make a one-dimensional row packed copy of the internal array.
+ @return Matrix elements packed in a one-dimensional array by rows.
+ */
+
+ public double[] getRowPackedCopy () {
+ double[] vals = new double[m*n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ vals[i*n+j] = A[i][j];
+ }
+ }
+ return vals;
+ }
+
+ /** Get row dimension.
+ @return m, the number of rows.
+ */
+
+ public int getRowDimension () {
+ return m;
+ }
+
+ /** Get column dimension.
+ @return n, the number of columns.
+ */
+
+ public int getColumnDimension () {
+ return n;
+ }
+
+ /** Get a single element.
+ @param i Row index.
+ @param j Column index.
+ @return A(i,j)
+ @exception ArrayIndexOutOfBoundsException
+ */
+
+ public double get (int i, int j) {
+ return A[i][j];
+ }
+
+ /** Get a submatrix.
+ @param i0 Initial row index
+ @param i1 Final row index
+ @param j0 Initial column index
+ @param j1 Final column index
+ @return A(i0:i1,j0:j1)
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public Matrix getMatrix (int i0, int i1, int j0, int j1) {
+ Matrix X = new Matrix(i1-i0+1,j1-j0+1);
+ double[][] B = X.getArray();
+ try {
+ for (int i = i0; i <= i1; i++) {
+ for (int j = j0; j <= j1; j++) {
+ B[i-i0][j-j0] = A[i][j];
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ return X;
+ }
+
+ /** Get a submatrix.
+ @param r Array of row indices.
+ @param c Array of column indices.
+ @return A(r(:),c(:))
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public Matrix getMatrix (int[] r, int[] c) {
+ Matrix X = new Matrix(r.length,c.length);
+ double[][] B = X.getArray();
+ try {
+ for (int i = 0; i < r.length; i++) {
+ for (int j = 0; j < c.length; j++) {
+ B[i][j] = A[r[i]][c[j]];
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ return X;
+ }
+
+ /** Get a submatrix.
+ @param i0 Initial row index
+ @param i1 Final row index
+ @param c Array of column indices.
+ @return A(i0:i1,c(:))
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public Matrix getMatrix (int i0, int i1, int[] c) {
+ Matrix X = new Matrix(i1-i0+1,c.length);
+ double[][] B = X.getArray();
+ try {
+ for (int i = i0; i <= i1; i++) {
+ for (int j = 0; j < c.length; j++) {
+ B[i-i0][j] = A[i][c[j]];
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ return X;
+ }
+
+ /** Get a submatrix.
+ @param r Array of row indices.
+ @param j0 Initial column index
+ @param j1 Final column index
+ @return A(r(:),j0:j1)
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public Matrix getMatrix (int[] r, int j0, int j1) {
+ Matrix X = new Matrix(r.length,j1-j0+1);
+ double[][] B = X.getArray();
+ try {
+ for (int i = 0; i < r.length; i++) {
+ for (int j = j0; j <= j1; j++) {
+ B[i][j-j0] = A[r[i]][j];
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ return X;
+ }
+
+ /** Set a single element.
+ @param i Row index.
+ @param j Column index.
+ @param s A(i,j).
+ @exception ArrayIndexOutOfBoundsException
+ */
+
+ public void set (int i, int j, double s) {
+ A[i][j] = s;
+ }
+
+ /** Set a submatrix.
+ @param i0 Initial row index
+ @param i1 Final row index
+ @param j0 Initial column index
+ @param j1 Final column index
+ @param X A(i0:i1,j0:j1)
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public void setMatrix (int i0, int i1, int j0, int j1, Matrix X) {
+ try {
+ for (int i = i0; i <= i1; i++) {
+ for (int j = j0; j <= j1; j++) {
+ A[i][j] = X.get(i-i0,j-j0);
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ }
+
+ /** Set a submatrix.
+ @param r Array of row indices.
+ @param c Array of column indices.
+ @param X A(r(:),c(:))
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public void setMatrix (int[] r, int[] c, Matrix X) {
+ try {
+ for (int i = 0; i < r.length; i++) {
+ for (int j = 0; j < c.length; j++) {
+ A[r[i]][c[j]] = X.get(i,j);
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ }
+
+ /** Set a submatrix.
+ @param r Array of row indices.
+ @param j0 Initial column index
+ @param j1 Final column index
+ @param X A(r(:),j0:j1)
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public void setMatrix (int[] r, int j0, int j1, Matrix X) {
+ try {
+ for (int i = 0; i < r.length; i++) {
+ for (int j = j0; j <= j1; j++) {
+ A[r[i]][j] = X.get(i,j-j0);
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ }
+
+ /** Set a submatrix.
+ @param i0 Initial row index
+ @param i1 Final row index
+ @param c Array of column indices.
+ @param X A(i0:i1,c(:))
+ @exception ArrayIndexOutOfBoundsException Submatrix indices
+ */
+
+ public void setMatrix (int i0, int i1, int[] c, Matrix X) {
+ try {
+ for (int i = i0; i <= i1; i++) {
+ for (int j = 0; j < c.length; j++) {
+ A[i][c[j]] = X.get(i-i0,j);
+ }
+ }
+ } catch(ArrayIndexOutOfBoundsException e) {
+ throw new ArrayIndexOutOfBoundsException("Submatrix indices");
+ }
+ }
+
+ /** Matrix transpose.
+ @return A'
+ */
+
+ public Matrix transpose () {
+ Matrix X = new Matrix(n,m);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[j][i] = A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** One norm
+ @return maximum column sum.
+ */
+
+ public double norm1 () {
+ double f = 0;
+ for (int j = 0; j < n; j++) {
+ double s = 0;
+ for (int i = 0; i < m; i++) {
+ s += Math.abs(A[i][j]);
+ }
+ f = Math.max(f,s);
+ }
+ return f;
+ }
+
+ /** Two norm
+ @return maximum singular value.
+ */
+
+ public double norm2 () {
+ return (new SingularValueDecomposition(this).norm2());
+ }
+
+ /** Infinity norm
+ @return maximum row sum.
+ */
+
+ public double normInf () {
+ double f = 0;
+ for (int i = 0; i < m; i++) {
+ double s = 0;
+ for (int j = 0; j < n; j++) {
+ s += Math.abs(A[i][j]);
+ }
+ f = Math.max(f,s);
+ }
+ return f;
+ }
+
+ /** Frobenius norm
+ @return sqrt of sum of squares of all elements.
+ */
+
+ public double normF () {
+ double f = 0;
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ f = Maths.hypot(f,A[i][j]);
+ }
+ }
+ return f;
+ }
+
+ /** Unary minus
+ @return -A
+ */
+
+ public Matrix uminus () {
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = -A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** C = A + B
+ @param B another matrix
+ @return A + B
+ */
+
+ public Matrix plus (Matrix B) {
+ checkMatrixDimensions(B);
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = A[i][j] + B.A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** A = A + B
+ @param B another matrix
+ @return A + B
+ */
+
+ public Matrix plusEquals (Matrix B) {
+ checkMatrixDimensions(B);
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = A[i][j] + B.A[i][j];
+ }
+ }
+ return this;
+ }
+
+ /** C = A - B
+ @param B another matrix
+ @return A - B
+ */
+
+ public Matrix minus (Matrix B) {
+ checkMatrixDimensions(B);
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = A[i][j] - B.A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** A = A - B
+ @param B another matrix
+ @return A - B
+ */
+
+ public Matrix minusEquals (Matrix B) {
+ checkMatrixDimensions(B);
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = A[i][j] - B.A[i][j];
+ }
+ }
+ return this;
+ }
+
+ /** Element-by-element multiplication, C = A.*B
+ @param B another matrix
+ @return A.*B
+ */
+
+ public Matrix arrayTimes (Matrix B) {
+ checkMatrixDimensions(B);
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = A[i][j] * B.A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** Element-by-element multiplication in place, A = A.*B
+ @param B another matrix
+ @return A.*B
+ */
+
+ public Matrix arrayTimesEquals (Matrix B) {
+ checkMatrixDimensions(B);
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = A[i][j] * B.A[i][j];
+ }
+ }
+ return this;
+ }
+
+ /** Element-by-element right division, C = A./B
+ @param B another matrix
+ @return A./B
+ */
+
+ public Matrix arrayRightDivide (Matrix B) {
+ checkMatrixDimensions(B);
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = A[i][j] / B.A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** Element-by-element right division in place, A = A./B
+ @param B another matrix
+ @return A./B
+ */
+
+ public Matrix arrayRightDivideEquals (Matrix B) {
+ checkMatrixDimensions(B);
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = A[i][j] / B.A[i][j];
+ }
+ }
+ return this;
+ }
+
+ /** Element-by-element left division, C = A.\B
+ @param B another matrix
+ @return A.\B
+ */
+
+ public Matrix arrayLeftDivide (Matrix B) {
+ checkMatrixDimensions(B);
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = B.A[i][j] / A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** Element-by-element left division in place, A = A.\B
+ @param B another matrix
+ @return A.\B
+ */
+
+ public Matrix arrayLeftDivideEquals (Matrix B) {
+ checkMatrixDimensions(B);
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = B.A[i][j] / A[i][j];
+ }
+ }
+ return this;
+ }
+
+ /** Multiply a matrix by a scalar, C = s*A
+ @param s scalar
+ @return s*A
+ */
+
+ public Matrix times (double s) {
+ Matrix X = new Matrix(m,n);
+ double[][] C = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ C[i][j] = s*A[i][j];
+ }
+ }
+ return X;
+ }
+
+ /** Multiply a matrix by a scalar in place, A = s*A
+ @param s scalar
+ @return replace A by s*A
+ */
+
+ public Matrix timesEquals (double s) {
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ A[i][j] = s*A[i][j];
+ }
+ }
+ return this;
+ }
+
+ /** Linear algebraic matrix multiplication, A * B
+ @param B another matrix
+ @return Matrix product, A * B
+ @exception IllegalArgumentException Matrix inner dimensions must agree.
+ */
+
+ public Matrix times (Matrix B) {
+ if (B.m != n) {
+ throw new IllegalArgumentException("Matrix inner dimensions must agree.");
+ }
+ Matrix X = new Matrix(m,B.n);
+ double[][] C = X.getArray();
+ double[] Bcolj = new double[n];
+ for (int j = 0; j < B.n; j++) {
+ for (int k = 0; k < n; k++) {
+ Bcolj[k] = B.A[k][j];
+ }
+ for (int i = 0; i < m; i++) {
+ double[] Arowi = A[i];
+ double s = 0;
+ for (int k = 0; k < n; k++) {
+ s += Arowi[k]*Bcolj[k];
+ }
+ C[i][j] = s;
+ }
+ }
+ return X;
+ }
+
+ /** LU Decomposition
+ @return LUDecomposition
+ @see LUDecomposition
+ */
+
+ public LUDecomposition lu () {
+ return new LUDecomposition(this);
+ }
+
+ /** QR Decomposition
+ @return QRDecomposition
+ @see QRDecomposition
+ */
+
+ public QRDecomposition qr () {
+ return new QRDecomposition(this);
+ }
+
+ /** Cholesky Decomposition
+ @return CholeskyDecomposition
+ @see CholeskyDecomposition
+ */
+
+ public CholeskyDecomposition chol () {
+ return new CholeskyDecomposition(this);
+ }
+
+ /** Singular Value Decomposition
+ @return SingularValueDecomposition
+ @see SingularValueDecomposition
+ */
+
+ public SingularValueDecomposition svd () {
+ return new SingularValueDecomposition(this);
+ }
+
+ /** Eigenvalue Decomposition
+ @return EigenvalueDecomposition
+ @see EigenvalueDecomposition
+ */
+
+ public EigenvalueDecomposition eig () {
+ return new EigenvalueDecomposition(this);
+ }
+
+ /** Solve A*X = B
+ @param B right hand side
+ @return solution if A is square, least squares solution otherwise
+ */
+
+ public Matrix solve (Matrix B) {
+ return (m == n ? (new LUDecomposition(this)).solve(B) :
+ (new QRDecomposition(this)).solve(B));
+ }
+
+ /** Solve X*A = B, which is also A'*X' = B'
+ @param B right hand side
+ @return solution if A is square, least squares solution otherwise.
+ */
+
+ public Matrix solveTranspose (Matrix B) {
+ return transpose().solve(B.transpose());
+ }
+
+ /** Matrix inverse or pseudoinverse
+ @return inverse(A) if A is square, pseudoinverse otherwise.
+ */
+
+ public Matrix inverse () {
+ return solve(identity(m,m));
+ }
+
+ /** Matrix determinant
+ @return determinant
+ */
+
+ public double det () {
+ return new LUDecomposition(this).det();
+ }
+
+ /** Matrix rank
+ @return effective numerical rank, obtained from SVD.
+ */
+
+ public int rank () {
+ return new SingularValueDecomposition(this).rank();
+ }
+
+ /** Matrix condition (2 norm)
+ @return ratio of largest to smallest singular value.
+ */
+
+ public double cond () {
+ return new SingularValueDecomposition(this).cond();
+ }
+
+ /** Matrix trace.
+ @return sum of the diagonal elements.
+ */
+
+ public double trace () {
+ double t = 0;
+ for (int i = 0; i < Math.min(m,n); i++) {
+ t += A[i][i];
+ }
+ return t;
+ }
+
+ /** Generate matrix with random elements
+ @param m Number of rows.
+ @param n Number of colums.
+ @return An m-by-n matrix with uniformly distributed random elements.
+ */
+
+ public static Matrix random (int m, int n) {
+ Matrix A = new Matrix(m,n);
+ double[][] X = A.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ X[i][j] = Math.random();
+ }
+ }
+ return A;
+ }
+
+ /** Generate identity matrix
+ @param m Number of rows.
+ @param n Number of colums.
+ @return An m-by-n matrix with ones on the diagonal and zeros elsewhere.
+ */
+
+ public static Matrix identity (int m, int n) {
+ Matrix A = new Matrix(m,n);
+ double[][] X = A.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ X[i][j] = (i == j ? 1.0 : 0.0);
+ }
+ }
+ return A;
+ }
+
+
+ /** Print the matrix to stdout. Line the elements up in columns
+ * with a Fortran-like 'Fw.d' style format.
+ @param w Column width.
+ @param d Number of digits after the decimal.
+ */
+
+ public void print (int w, int d) {
+ print(new PrintWriter(System.out,true),w,d); }
+
+ /** Print the matrix to the output stream. Line the elements up in
+ * columns with a Fortran-like 'Fw.d' style format.
+ @param output Output stream.
+ @param w Column width.
+ @param d Number of digits after the decimal.
+ */
+
+ public void print (PrintWriter output, int w, int d) {
+ DecimalFormat format = new DecimalFormat();
+ format.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US));
+ format.setMinimumIntegerDigits(1);
+ format.setMaximumFractionDigits(d);
+ format.setMinimumFractionDigits(d);
+ format.setGroupingUsed(false);
+ print(output,format,w+2);
+ }
+
+ /** Print the matrix to stdout. Line the elements up in columns.
+ * Use the format object, and right justify within columns of width
+ * characters.
+ * Note that is the matrix is to be read back in, you probably will want
+ * to use a NumberFormat that is set to US Locale.
+ @param format A Formatting object for individual elements.
+ @param width Field width for each column.
+ @see java.text.DecimalFormat#setDecimalFormatSymbols
+ */
+
+ public void print (NumberFormat format, int width) {
+ print(new PrintWriter(System.out,true),format,width); }
+
+ // DecimalFormat is a little disappointing coming from Fortran or C's printf.
+ // Since it doesn't pad on the left, the elements will come out different
+ // widths. Consequently, we'll pass the desired column width in as an
+ // argument and do the extra padding ourselves.
+
+ /** Print the matrix to the output stream. Line the elements up in columns.
+ * Use the format object, and right justify within columns of width
+ * characters.
+ * Note that is the matrix is to be read back in, you probably will want
+ * to use a NumberFormat that is set to US Locale.
+ @param output the output stream.
+ @param format A formatting object to format the matrix elements
+ @param width Column width.
+ @see java.text.DecimalFormat#setDecimalFormatSymbols
+ */
+
+ public void print (PrintWriter output, NumberFormat format, int width) {
+ output.println(); // start on new line.
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ String s = format.format(A[i][j]); // format the number
+ int padding = Math.max(1,width-s.length()); // At _least_ 1 space
+ for (int k = 0; k < padding; k++)
+ output.print(' ');
+ output.print(s);
+ }
+ output.println();
+ }
+ output.println(); // end with blank line.
+ }
+
+ /** Read a matrix from a stream. The format is the same the print method,
+ * so printed matrices can be read back in (provided they were printed using
+ * US Locale). Elements are separated by
+ * whitespace, all the elements for each row appear on a single line,
+ * the last row is followed by a blank line.
+ @param input the input stream.
+ */
+
+ public static Matrix read (BufferedReader input) throws java.io.IOException {
+ StreamTokenizer tokenizer= new StreamTokenizer(input);
+
+ // Although StreamTokenizer will parse numbers, it doesn't recognize
+ // scientific notation (E or D); however, Double.valueOf does.
+ // The strategy here is to disable StreamTokenizer's number parsing.
+ // We'll only get whitespace delimited words, EOL's and EOF's.
+ // These words should all be numbers, for Double.valueOf to parse.
+
+ tokenizer.resetSyntax();
+ tokenizer.wordChars(0,255);
+ tokenizer.whitespaceChars(0, ' ');
+ tokenizer.eolIsSignificant(true);
+ java.util.Vector vD = new java.util.Vector();
+
+ // Ignore initial empty lines
+ while (tokenizer.nextToken() == StreamTokenizer.TT_EOL);
+ if (tokenizer.ttype == StreamTokenizer.TT_EOF)
+ throw new java.io.IOException("Unexpected EOF on matrix read.");
+ do {
+ vD.addElement(Double.valueOf(tokenizer.sval)); // Read & store 1st row.
+ } while (tokenizer.nextToken() == StreamTokenizer.TT_WORD);
+
+ int n = vD.size(); // Now we've got the number of columns!
+ double row[] = new double[n];
+ for (int j=0; j v = new java.util.Vector();
+ v.addElement(row); // Start storing rows instead of columns.
+ while (tokenizer.nextToken() == StreamTokenizer.TT_WORD) {
+ // While non-empty lines
+ v.addElement(row = new double[n]);
+ int j = 0;
+ do {
+ if (j >= n) throw new java.io.IOException
+ ("Row " + v.size() + " is too long.");
+ row[j++] = Double.valueOf(tokenizer.sval).doubleValue();
+ } while (tokenizer.nextToken() == StreamTokenizer.TT_WORD);
+ if (j < n) throw new java.io.IOException
+ ("Row " + v.size() + " is too short.");
+ }
+ int m = v.size(); // Now we've got the number of rows.
+ double[][] A = new double[m][];
+ v.copyInto(A); // copy the rows out of the vector
+ return new Matrix(A);
+ }
+
+
+/* ------------------------
+ Private Methods
+ * ------------------------ */
+
+ /** Check if size(A) == size(B) **/
+
+ private void checkMatrixDimensions (Matrix B) {
+ if (B.m != m || B.n != n) {
+ throw new IllegalArgumentException("Matrix dimensions must agree.");
+ }
+ }
+
+ private static final long serialVersionUID = 1;
+}
diff --git a/Java/src/Jama/QRDecomposition.java b/Java/src/Jama/QRDecomposition.java
new file mode 100644
index 00000000..10916be4
--- /dev/null
+++ b/Java/src/Jama/QRDecomposition.java
@@ -0,0 +1,219 @@
+package Jama;
+import Jama.util.*;
+
+/** QR Decomposition.
+
+ For an m-by-n matrix A with m >= n, the QR decomposition is an m-by-n
+ orthogonal matrix Q and an n-by-n upper triangular matrix R so that
+ A = Q*R.
+
+ The QR decompostion always exists, even if the matrix does not have
+ full rank, so the constructor will never fail. The primary use of the
+ QR decomposition is in the least squares solution of nonsquare systems
+ of simultaneous linear equations. This will fail if isFullRank()
+ returns false.
+*/
+
+public class QRDecomposition implements java.io.Serializable {
+
+/* ------------------------
+ Class variables
+ * ------------------------ */
+
+ /** Array for internal storage of decomposition.
+ @serial internal array storage.
+ */
+ private double[][] QR;
+
+ /** Row and column dimensions.
+ @serial column dimension.
+ @serial row dimension.
+ */
+ private int m, n;
+
+ /** Array for internal storage of diagonal of R.
+ @serial diagonal of R.
+ */
+ private double[] Rdiag;
+
+/* ------------------------
+ Constructor
+ * ------------------------ */
+
+ /** QR Decomposition, computed by Householder reflections.
+ Structure to access R and the Householder vectors and compute Q.
+ @param A Rectangular matrix
+ */
+
+ public QRDecomposition (Matrix A) {
+ // Initialize.
+ QR = A.getArrayCopy();
+ m = A.getRowDimension();
+ n = A.getColumnDimension();
+ Rdiag = new double[n];
+
+ // Main loop.
+ for (int k = 0; k < n; k++) {
+ // Compute 2-norm of k-th column without under/overflow.
+ double nrm = 0;
+ for (int i = k; i < m; i++) {
+ nrm = Maths.hypot(nrm,QR[i][k]);
+ }
+
+ if (nrm != 0.0) {
+ // Form k-th Householder vector.
+ if (QR[k][k] < 0) {
+ nrm = -nrm;
+ }
+ for (int i = k; i < m; i++) {
+ QR[i][k] /= nrm;
+ }
+ QR[k][k] += 1.0;
+
+ // Apply transformation to remaining columns.
+ for (int j = k+1; j < n; j++) {
+ double s = 0.0;
+ for (int i = k; i < m; i++) {
+ s += QR[i][k]*QR[i][j];
+ }
+ s = -s/QR[k][k];
+ for (int i = k; i < m; i++) {
+ QR[i][j] += s*QR[i][k];
+ }
+ }
+ }
+ Rdiag[k] = -nrm;
+ }
+ }
+
+/* ------------------------
+ Public Methods
+ * ------------------------ */
+
+ /** Is the matrix full rank?
+ @return true if R, and hence A, has full rank.
+ */
+
+ public boolean isFullRank () {
+ for (int j = 0; j < n; j++) {
+ if (Rdiag[j] == 0)
+ return false;
+ }
+ return true;
+ }
+
+ /** Return the Householder vectors
+ @return Lower trapezoidal matrix whose columns define the reflections
+ */
+
+ public Matrix getH () {
+ Matrix X = new Matrix(m,n);
+ double[][] H = X.getArray();
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (i >= j) {
+ H[i][j] = QR[i][j];
+ } else {
+ H[i][j] = 0.0;
+ }
+ }
+ }
+ return X;
+ }
+
+ /** Return the upper triangular factor
+ @return R
+ */
+
+ public Matrix getR () {
+ Matrix X = new Matrix(n,n);
+ double[][] R = X.getArray();
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ if (i < j) {
+ R[i][j] = QR[i][j];
+ } else if (i == j) {
+ R[i][j] = Rdiag[i];
+ } else {
+ R[i][j] = 0.0;
+ }
+ }
+ }
+ return X;
+ }
+
+ /** Generate and return the (economy-sized) orthogonal factor
+ @return Q
+ */
+
+ public Matrix getQ () {
+ Matrix X = new Matrix(m,n);
+ double[][] Q = X.getArray();
+ for (int k = n-1; k >= 0; k--) {
+ for (int i = 0; i < m; i++) {
+ Q[i][k] = 0.0;
+ }
+ Q[k][k] = 1.0;
+ for (int j = k; j < n; j++) {
+ if (QR[k][k] != 0) {
+ double s = 0.0;
+ for (int i = k; i < m; i++) {
+ s += QR[i][k]*Q[i][j];
+ }
+ s = -s/QR[k][k];
+ for (int i = k; i < m; i++) {
+ Q[i][j] += s*QR[i][k];
+ }
+ }
+ }
+ }
+ return X;
+ }
+
+ /** Least squares solution of A*X = B
+ @param B A Matrix with as many rows as A and any number of columns.
+ @return X that minimizes the two norm of Q*R*X-B.
+ @exception IllegalArgumentException Matrix row dimensions must agree.
+ @exception RuntimeException Matrix is rank deficient.
+ */
+
+ public Matrix solve (Matrix B) {
+ if (B.getRowDimension() != m) {
+ throw new IllegalArgumentException("Matrix row dimensions must agree.");
+ }
+ if (!this.isFullRank()) {
+ throw new RuntimeException("Matrix is rank deficient.");
+ }
+
+ // Copy right hand side
+ int nx = B.getColumnDimension();
+ double[][] X = B.getArrayCopy();
+
+ // Compute Y = transpose(Q)*B
+ for (int k = 0; k < n; k++) {
+ for (int j = 0; j < nx; j++) {
+ double s = 0.0;
+ for (int i = k; i < m; i++) {
+ s += QR[i][k]*X[i][j];
+ }
+ s = -s/QR[k][k];
+ for (int i = k; i < m; i++) {
+ X[i][j] += s*QR[i][k];
+ }
+ }
+ }
+ // Solve R*X = Y;
+ for (int k = n-1; k >= 0; k--) {
+ for (int j = 0; j < nx; j++) {
+ X[k][j] /= Rdiag[k];
+ }
+ for (int i = 0; i < k; i++) {
+ for (int j = 0; j < nx; j++) {
+ X[i][j] -= X[k][j]*QR[i][k];
+ }
+ }
+ }
+ return (new Matrix(X,n,nx).getMatrix(0,n-1,0,nx-1));
+ }
+ private static final long serialVersionUID = 1;
+}
diff --git a/Java/src/Jama/SingularValueDecomposition.java b/Java/src/Jama/SingularValueDecomposition.java
new file mode 100644
index 00000000..b289e82f
--- /dev/null
+++ b/Java/src/Jama/SingularValueDecomposition.java
@@ -0,0 +1,548 @@
+package Jama;
+import Jama.util.*;
+
+ /** Singular Value Decomposition.
+
+ For an m-by-n matrix A with m >= n, the singular value decomposition is
+ an m-by-n orthogonal matrix U, an n-by-n diagonal matrix S, and
+ an n-by-n orthogonal matrix V so that A = U*S*V'.
+
+ The singular values, sigma[k] = S[k][k], are ordered so that
+ sigma[0] >= sigma[1] >= ... >= sigma[n-1].
+
+ The singular value decompostion always exists, so the constructor will
+ never fail. The matrix condition number and the effective numerical
+ rank can be computed from this decomposition.
+ */
+
+public class SingularValueDecomposition implements java.io.Serializable {
+
+/* ------------------------
+ Class variables
+ * ------------------------ */
+
+ /** Arrays for internal storage of U and V.
+ @serial internal storage of U.
+ @serial internal storage of V.
+ */
+ private double[][] U, V;
+
+ /** Array for internal storage of singular values.
+ @serial internal storage of singular values.
+ */
+ private double[] s;
+
+ /** Row and column dimensions.
+ @serial row dimension.
+ @serial column dimension.
+ */
+ private int m, n;
+
+/* ------------------------
+ Constructor
+ * ------------------------ */
+
+ /** Construct the singular value decomposition
+ Structure to access U, S and V.
+ @param Arg Rectangular matrix
+ */
+
+ public SingularValueDecomposition (Matrix Arg) {
+
+ // Derived from LINPACK code.
+ // Initialize.
+ double[][] A = Arg.getArrayCopy();
+ m = Arg.getRowDimension();
+ n = Arg.getColumnDimension();
+
+ /* Apparently the failing cases are only a proper subset of (m= n"); }
+ */
+ int nu = Math.min(m,n);
+ s = new double [Math.min(m+1,n)];
+ U = new double [m][nu];
+ V = new double [n][n];
+ double[] e = new double [n];
+ double[] work = new double [m];
+ boolean wantu = true;
+ boolean wantv = true;
+
+ // Reduce A to bidiagonal form, storing the diagonal elements
+ // in s and the super-diagonal elements in e.
+
+ int nct = Math.min(m-1,n);
+ int nrt = Math.max(0,Math.min(n-2,m));
+ for (int k = 0; k < Math.max(nct,nrt); k++) {
+ if (k < nct) {
+
+ // Compute the transformation for the k-th column and
+ // place the k-th diagonal in s[k].
+ // Compute 2-norm of k-th column without under/overflow.
+ s[k] = 0;
+ for (int i = k; i < m; i++) {
+ s[k] = Maths.hypot(s[k],A[i][k]);
+ }
+ if (s[k] != 0.0) {
+ if (A[k][k] < 0.0) {
+ s[k] = -s[k];
+ }
+ for (int i = k; i < m; i++) {
+ A[i][k] /= s[k];
+ }
+ A[k][k] += 1.0;
+ }
+ s[k] = -s[k];
+ }
+ for (int j = k+1; j < n; j++) {
+ if ((k < nct) & (s[k] != 0.0)) {
+
+ // Apply the transformation.
+
+ double t = 0;
+ for (int i = k; i < m; i++) {
+ t += A[i][k]*A[i][j];
+ }
+ t = -t/A[k][k];
+ for (int i = k; i < m; i++) {
+ A[i][j] += t*A[i][k];
+ }
+ }
+
+ // Place the k-th row of A into e for the
+ // subsequent calculation of the row transformation.
+
+ e[j] = A[k][j];
+ }
+ if (wantu & (k < nct)) {
+
+ // Place the transformation in U for subsequent back
+ // multiplication.
+
+ for (int i = k; i < m; i++) {
+ U[i][k] = A[i][k];
+ }
+ }
+ if (k < nrt) {
+
+ // Compute the k-th row transformation and place the
+ // k-th super-diagonal in e[k].
+ // Compute 2-norm without under/overflow.
+ e[k] = 0;
+ for (int i = k+1; i < n; i++) {
+ e[k] = Maths.hypot(e[k],e[i]);
+ }
+ if (e[k] != 0.0) {
+ if (e[k+1] < 0.0) {
+ e[k] = -e[k];
+ }
+ for (int i = k+1; i < n; i++) {
+ e[i] /= e[k];
+ }
+ e[k+1] += 1.0;
+ }
+ e[k] = -e[k];
+ if ((k+1 < m) & (e[k] != 0.0)) {
+
+ // Apply the transformation.
+
+ for (int i = k+1; i < m; i++) {
+ work[i] = 0.0;
+ }
+ for (int j = k+1; j < n; j++) {
+ for (int i = k+1; i < m; i++) {
+ work[i] += e[j]*A[i][j];
+ }
+ }
+ for (int j = k+1; j < n; j++) {
+ double t = -e[j]/e[k+1];
+ for (int i = k+1; i < m; i++) {
+ A[i][j] += t*work[i];
+ }
+ }
+ }
+ if (wantv) {
+
+ // Place the transformation in V for subsequent
+ // back multiplication.
+
+ for (int i = k+1; i < n; i++) {
+ V[i][k] = e[i];
+ }
+ }
+ }
+ }
+
+ // Set up the final bidiagonal matrix or order p.
+
+ int p = Math.min(n,m+1);
+ if (nct < n) {
+ s[nct] = A[nct][nct];
+ }
+ if (m < p) {
+ s[p-1] = 0.0;
+ }
+ if (nrt+1 < p) {
+ e[nrt] = A[nrt][p-1];
+ }
+ e[p-1] = 0.0;
+
+ // If required, generate U.
+
+ if (wantu) {
+ for (int j = nct; j < nu; j++) {
+ for (int i = 0; i < m; i++) {
+ U[i][j] = 0.0;
+ }
+ U[j][j] = 1.0;
+ }
+ for (int k = nct-1; k >= 0; k--) {
+ if (s[k] != 0.0) {
+ for (int j = k+1; j < nu; j++) {
+ double t = 0;
+ for (int i = k; i < m; i++) {
+ t += U[i][k]*U[i][j];
+ }
+ t = -t/U[k][k];
+ for (int i = k; i < m; i++) {
+ U[i][j] += t*U[i][k];
+ }
+ }
+ for (int i = k; i < m; i++ ) {
+ U[i][k] = -U[i][k];
+ }
+ U[k][k] = 1.0 + U[k][k];
+ for (int i = 0; i < k-1; i++) {
+ U[i][k] = 0.0;
+ }
+ } else {
+ for (int i = 0; i < m; i++) {
+ U[i][k] = 0.0;
+ }
+ U[k][k] = 1.0;
+ }
+ }
+ }
+
+ // If required, generate V.
+
+ if (wantv) {
+ for (int k = n-1; k >= 0; k--) {
+ if ((k < nrt) & (e[k] != 0.0)) {
+ for (int j = k+1; j < nu; j++) {
+ double t = 0;
+ for (int i = k+1; i < n; i++) {
+ t += V[i][k]*V[i][j];
+ }
+ t = -t/V[k+1][k];
+ for (int i = k+1; i < n; i++) {
+ V[i][j] += t*V[i][k];
+ }
+ }
+ }
+ for (int i = 0; i < n; i++) {
+ V[i][k] = 0.0;
+ }
+ V[k][k] = 1.0;
+ }
+ }
+
+ // Main iteration loop for the singular values.
+
+ int pp = p-1;
+ int iter = 0;
+ double eps = Math.pow(2.0,-52.0);
+ double tiny = Math.pow(2.0,-966.0);
+ while (p > 0) {
+ int k,kase;
+
+ // Here is where a test for too many iterations would go.
+
+ // This section of the program inspects for
+ // negligible elements in the s and e arrays. On
+ // completion the variables kase and k are set as follows.
+
+ // kase = 1 if s(p) and e[k-1] are negligible and k
= -1; k--) {
+ if (k == -1) {
+ break;
+ }
+ if (Math.abs(e[k]) <=
+ tiny + eps*(Math.abs(s[k]) + Math.abs(s[k+1]))) {
+ e[k] = 0.0;
+ break;
+ }
+ }
+ if (k == p-2) {
+ kase = 4;
+ } else {
+ int ks;
+ for (ks = p-1; ks >= k; ks--) {
+ if (ks == k) {
+ break;
+ }
+ double t = (ks != p ? Math.abs(e[ks]) : 0.) +
+ (ks != k+1 ? Math.abs(e[ks-1]) : 0.);
+ if (Math.abs(s[ks]) <= tiny + eps*t) {
+ s[ks] = 0.0;
+ break;
+ }
+ }
+ if (ks == k) {
+ kase = 3;
+ } else if (ks == p-1) {
+ kase = 1;
+ } else {
+ kase = 2;
+ k = ks;
+ }
+ }
+ k++;
+
+ // Perform the task indicated by kase.
+
+ switch (kase) {
+
+ // Deflate negligible s(p).
+
+ case 1: {
+ double f = e[p-2];
+ e[p-2] = 0.0;
+ for (int j = p-2; j >= k; j--) {
+ double t = Maths.hypot(s[j],f);
+ double cs = s[j]/t;
+ double sn = f/t;
+ s[j] = t;
+ if (j != k) {
+ f = -sn*e[j-1];
+ e[j-1] = cs*e[j-1];
+ }
+ if (wantv) {
+ for (int i = 0; i < n; i++) {
+ t = cs*V[i][j] + sn*V[i][p-1];
+ V[i][p-1] = -sn*V[i][j] + cs*V[i][p-1];
+ V[i][j] = t;
+ }
+ }
+ }
+ }
+ break;
+
+ // Split at negligible s(k).
+
+ case 2: {
+ double f = e[k-1];
+ e[k-1] = 0.0;
+ for (int j = k; j < p; j++) {
+ double t = Maths.hypot(s[j],f);
+ double cs = s[j]/t;
+ double sn = f/t;
+ s[j] = t;
+ f = -sn*e[j];
+ e[j] = cs*e[j];
+ if (wantu) {
+ for (int i = 0; i < m; i++) {
+ t = cs*U[i][j] + sn*U[i][k-1];
+ U[i][k-1] = -sn*U[i][j] + cs*U[i][k-1];
+ U[i][j] = t;
+ }
+ }
+ }
+ }
+ break;
+
+ // Perform one qr step.
+
+ case 3: {
+
+ // Calculate the shift.
+
+ double scale = Math.max(Math.max(Math.max(Math.max(
+ Math.abs(s[p-1]),Math.abs(s[p-2])),Math.abs(e[p-2])),
+ Math.abs(s[k])),Math.abs(e[k]));
+ double sp = s[p-1]/scale;
+ double spm1 = s[p-2]/scale;
+ double epm1 = e[p-2]/scale;
+ double sk = s[k]/scale;
+ double ek = e[k]/scale;
+ double b = ((spm1 + sp)*(spm1 - sp) + epm1*epm1)/2.0;
+ double c = (sp*epm1)*(sp*epm1);
+ double shift = 0.0;
+ if ((b != 0.0) | (c != 0.0)) {
+ shift = Math.sqrt(b*b + c);
+ if (b < 0.0) {
+ shift = -shift;
+ }
+ shift = c/(b + shift);
+ }
+ double f = (sk + sp)*(sk - sp) + shift;
+ double g = sk*ek;
+
+ // Chase zeros.
+
+ for (int j = k; j < p-1; j++) {
+ double t = Maths.hypot(f,g);
+ double cs = f/t;
+ double sn = g/t;
+ if (j != k) {
+ e[j-1] = t;
+ }
+ f = cs*s[j] + sn*e[j];
+ e[j] = cs*e[j] - sn*s[j];
+ g = sn*s[j+1];
+ s[j+1] = cs*s[j+1];
+ if (wantv) {
+ for (int i = 0; i < n; i++) {
+ t = cs*V[i][j] + sn*V[i][j+1];
+ V[i][j+1] = -sn*V[i][j] + cs*V[i][j+1];
+ V[i][j] = t;
+ }
+ }
+ t = Maths.hypot(f,g);
+ cs = f/t;
+ sn = g/t;
+ s[j] = t;
+ f = cs*e[j] + sn*s[j+1];
+ s[j+1] = -sn*e[j] + cs*s[j+1];
+ g = sn*e[j+1];
+ e[j+1] = cs*e[j+1];
+ if (wantu && (j < m-1)) {
+ for (int i = 0; i < m; i++) {
+ t = cs*U[i][j] + sn*U[i][j+1];
+ U[i][j+1] = -sn*U[i][j] + cs*U[i][j+1];
+ U[i][j] = t;
+ }
+ }
+ }
+ e[p-2] = f;
+ iter = iter + 1;
+ }
+ break;
+
+ // Convergence.
+
+ case 4: {
+
+ // Make the singular values positive.
+
+ if (s[k] <= 0.0) {
+ s[k] = (s[k] < 0.0 ? -s[k] : 0.0);
+ if (wantv) {
+ for (int i = 0; i <= pp; i++) {
+ V[i][k] = -V[i][k];
+ }
+ }
+ }
+
+ // Order the singular values.
+
+ while (k < pp) {
+ if (s[k] >= s[k+1]) {
+ break;
+ }
+ double t = s[k];
+ s[k] = s[k+1];
+ s[k+1] = t;
+ if (wantv && (k < n-1)) {
+ for (int i = 0; i < n; i++) {
+ t = V[i][k+1]; V[i][k+1] = V[i][k]; V[i][k] = t;
+ }
+ }
+ if (wantu && (k < m-1)) {
+ for (int i = 0; i < m; i++) {
+ t = U[i][k+1]; U[i][k+1] = U[i][k]; U[i][k] = t;
+ }
+ }
+ k++;
+ }
+ iter = 0;
+ p--;
+ }
+ break;
+ }
+ }
+ }
+
+/* ------------------------
+ Public Methods
+ * ------------------------ */
+
+ /** Return the left singular vectors
+ @return U
+ */
+
+ public Matrix getU () {
+ return new Matrix(U,m,Math.min(m+1,n));
+ }
+
+ /** Return the right singular vectors
+ @return V
+ */
+
+ public Matrix getV () {
+ return new Matrix(V,n,n);
+ }
+
+ /** Return the one-dimensional array of singular values
+ @return diagonal of S.
+ */
+
+ public double[] getSingularValues () {
+ return s;
+ }
+
+ /** Return the diagonal matrix of singular values
+ @return S
+ */
+
+ public Matrix getS () {
+ Matrix X = new Matrix(n,n);
+ double[][] S = X.getArray();
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ S[i][j] = 0.0;
+ }
+ S[i][i] = this.s[i];
+ }
+ return X;
+ }
+
+ /** Two norm
+ @return max(S)
+ */
+
+ public double norm2 () {
+ return s[0];
+ }
+
+ /** Two norm condition number
+ @return max(S)/min(S)
+ */
+
+ public double cond () {
+ return s[0]/s[Math.min(m,n)-1];
+ }
+
+ /** Effective numerical matrix rank
+ @return Number of nonnegligible singular values.
+ */
+
+ public int rank () {
+ double eps = Math.pow(2.0,-52.0);
+ double tol = Math.max(m,n)*s[0]*eps;
+ int r = 0;
+ for (int i = 0; i < s.length; i++) {
+ if (s[i] > tol) {
+ r++;
+ }
+ }
+ return r;
+ }
+ private static final long serialVersionUID = 1;
+}
diff --git a/Java/src/Jama/doc/Jama/CholeskyDecomposition.html b/Java/src/Jama/doc/Jama/CholeskyDecomposition.html
new file mode 100644
index 00000000..4f1721c2
--- /dev/null
+++ b/Java/src/Jama/doc/Jama/CholeskyDecomposition.html
@@ -0,0 +1,328 @@
+
+
+
+
+ For a symmetric, positive definite matrix A, the Cholesky decomposition
+ is an lower triangular matrix L so that A = L*L'.
+
+ If the matrix is not symmetric or positive definite, the constructor
+ returns a partial decomposition and sets an internal flag that may
+ be queried by the isSPD() method.
+
+ If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is
+ diagonal and the eigenvector matrix V is orthogonal.
+ I.e. A = V.times(D.times(V.transpose())) and
+ V.times(V.transpose()) equals the identity matrix.
+
+ If A is not symmetric, then the eigenvalue matrix D is block diagonal
+ with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
+ lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The
+ columns of V represent the eigenvectors in the sense that A*V = V*D,
+ i.e. A.times(V) equals V.times(D). The matrix V may be badly
+ conditioned, or even singular, so the validity of the equation
+ A = V*D*inverse(V) depends upon V.cond().
+
+ For an m-by-n matrix A with m >= n, the LU decomposition is an m-by-n
+ unit lower triangular matrix L, an n-by-n upper triangular matrix U,
+ and a permutation vector piv of length m so that A(piv,:) = L*U.
+ If m < n, then L is m-by-m and U is m-by-n.
+
+ The LU decompostion with pivoting always exists, even if the matrix is
+ singular, so the constructor will never fail. The primary use of the
+ LU decomposition is in the solution of square systems of simultaneous
+ linear equations. This will fail if isNonsingular() returns false.
+
+ The Java Matrix Class provides the fundamental operations of numerical
+ linear algebra. Various constructors create Matrices from two dimensional
+ arrays of double precision floating point numbers. Various "gets" and
+ "sets" provide access to submatrices and matrix elements. Several methods
+ implement basic matrix arithmetic, including matrix addition and
+ multiplication, matrix norms, and element-by-element array operations.
+ Methods for reading and printing matrices are also included. All the
+ operations in this version of the Matrix Class involve real matrices.
+ Complex matrices may be handled in a future version.
+
+ Five fundamental matrix decompositions, which consist of pairs or triples
+ of matrices, permutation vectors, and the like, produce results in five
+ decomposition classes. These decompositions are accessed by the Matrix
+ class to compute solutions of simultaneous linear equations, determinants,
+ inverses and other matrix functions. The five decompositions are:
+
+
Cholesky Decomposition of symmetric, positive definite matrices.
+
LU Decomposition of rectangular matrices.
+
QR Decomposition of rectangular matrices.
+
Singular Value Decomposition of rectangular matrices.
+
Eigenvalue Decomposition of both symmetric and nonsymmetric square matrices.
+
+
+
Example of use:
+
+
Solve a linear system A x = b and compute the residual norm, ||b - A x||.
+
+ double[][] vals = {{1.,2.,3},{4.,5.,6.},{7.,8.,10.}};
+ Matrix A = new Matrix(vals);
+ Matrix b = Matrix.random(3,1);
+ Matrix x = A.solve(b);
+ Matrix r = A.times(x).minus(b);
+ double rnorm = r.normInf();
+
An m-by-n matrix with ones on the diagonal and zeros elsewhere.
+
+
+
+
+
+print
+
+public void print(int w,
+ int d)
+
+
Print the matrix to stdout. Line the elements up in columns
+ with a Fortran-like 'Fw.d' style format.
+
+
+
+
+
+
Parameters:
w - Column width.
d - Number of digits after the decimal.
+
+
+
+
+
+print
+
+public void print(PrintWriter output,
+ int w,
+ int d)
+
+
Print the matrix to the output stream. Line the elements up in
+ columns with a Fortran-like 'Fw.d' style format.
+
+
+
+
+
+
Parameters:
output - Output stream.
w - Column width.
d - Number of digits after the decimal.
+
+
+
+
+
+print
+
+public void print(NumberFormat format,
+ int width)
+
+
Print the matrix to stdout. Line the elements up in columns.
+ Use the format object, and right justify within columns of width
+ characters.
+ Note that is the matrix is to be read back in, you probably will want
+ to use a NumberFormat that is set to US Locale.
+
+
+
+
+
+
Parameters:
format - A Formatting object for individual elements.
Print the matrix to the output stream. Line the elements up in columns.
+ Use the format object, and right justify within columns of width
+ characters.
+ Note that is the matrix is to be read back in, you probably will want
+ to use a NumberFormat that is set to US Locale.
+
+
+
+
+
+
Parameters:
output - the output stream.
format - A formatting object to format the matrix elements
Read a matrix from a stream. The format is the same the print method,
+ so printed matrices can be read back in (provided they were printed using
+ US Locale). Elements are separated by
+ whitespace, all the elements for each row appear on a single line,
+ the last row is followed by a blank line.
+
+ For an m-by-n matrix A with m >= n, the QR decomposition is an m-by-n
+ orthogonal matrix Q and an n-by-n upper triangular matrix R so that
+ A = Q*R.
+
+ The QR decompostion always exists, even if the matrix does not have
+ full rank, so the constructor will never fail. The primary use of the
+ QR decomposition is in the least squares solution of nonsquare systems
+ of simultaneous linear equations. This will fail if isFullRank()
+ returns false.
+
+ For an m-by-n matrix A with m >= n, the singular value decomposition is
+ an m-by-n orthogonal matrix U, an n-by-n diagonal matrix S, and
+ an n-by-n orthogonal matrix V so that A = U*S*V'.
+
+ The singular values, sigma[k] = S[k][k], are ordered so that
+ sigma[0] >= sigma[1] >= ... >= sigma[n-1].
+
+ The singular value decompostion always exists, so the constructor will
+ never fail. The matrix condition number and the effective numerical
+ rank can be computed from this decomposition.
+
+This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
+Package
+
+
+
+Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain four categories:
+
Interfaces (italic)
Classes
Enums
Exceptions
Errors
Annotation Types
+
+
+Class/Interface
+
+
+
+Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
+
Class inheritance diagram
Direct Subclasses
All Known Subinterfaces
All Known Implementing Classes
Class/interface declaration
Class/interface description
+
+
Nested Class Summary
Field Summary
Constructor Summary
Method Summary
+
+
Field Detail
Constructor Detail
Method Detail
+Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
+
+
+Annotation Type
+
+
+
+Each annotation type has its own separate page with the following sections:
+
Annotation Type declaration
Annotation Type description
Required Element Summary
Optional Element Summary
Element Detail
+
+
+
+Enum
+
+
+
+Each enum has its own separate page with the following sections:
+
Enum declaration
Enum description
Enum Constant Summary
Enum Constant Detail
+
+
+Tree (Class Hierarchy)
+
+There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
+
When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
+
+
+Deprecated API
+
+The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
+
+Index
+
+The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
+
+Prev/Next
+These links take you to the next or previous class, interface, package, or related page.
+Frames/No Frames
+These links show and hide the HTML frames. All pages are available with or without frames.
+
+
+Serialized Form
+Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
+
+
+
+
+
+
+
+
diff --git a/Java/src/Jama/doc/stylesheet.css b/Java/src/Jama/doc/stylesheet.css
new file mode 100644
index 00000000..6ea9e516
--- /dev/null
+++ b/Java/src/Jama/doc/stylesheet.css
@@ -0,0 +1,29 @@
+/* Javadoc style sheet */
+
+/* Define colors, fonts and other style attributes here to override the defaults */
+
+/* Page background color */
+body { background-color: #FFFFFF; color:#000000 }
+
+/* Headings */
+h1 { font-size: 145% }
+
+/* Table colors */
+.TableHeadingColor { background: #CCCCFF; color:#000000 } /* Dark mauve */
+.TableSubHeadingColor { background: #EEEEFF; color:#000000 } /* Light mauve */
+.TableRowColor { background: #FFFFFF; color:#000000 } /* White */
+
+/* Font used in left-hand frame lists */
+.FrameTitleFont { font-size: 100%; font-family: Helvetica, Arial, sans-serif; color:#000000 }
+.FrameHeadingFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 }
+.FrameItemFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 }
+
+/* Navigation bar fonts and colors */
+.NavBarCell1 { background-color:#EEEEFF; color:#000000} /* Light mauve */
+.NavBarCell1Rev { background-color:#00008B; color:#FFFFFF} /* Dark Blue */
+.NavBarFont1 { font-family: Arial, Helvetica, sans-serif; color:#000000;color:#000000;}
+.NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;color:#FFFFFF;}
+
+.NavBarCell2 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF; color:#000000}
+.NavBarCell3 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF; color:#000000}
+
diff --git a/Java/src/Jama/examples/MagicSquareExample.java b/Java/src/Jama/examples/MagicSquareExample.java
new file mode 100644
index 00000000..cf0b7db9
--- /dev/null
+++ b/Java/src/Jama/examples/MagicSquareExample.java
@@ -0,0 +1,163 @@
+package Jama.examples;
+import Jama.*;
+import java.util.Date;
+
+/** Example of use of Matrix Class, featuring magic squares. **/
+
+public class MagicSquareExample {
+
+ /** Generate magic square test matrix. **/
+
+ public static Matrix magic (int n) {
+
+ double[][] M = new double[n][n];
+
+ // Odd order
+
+ if ((n % 2) == 1) {
+ int a = (n+1)/2;
+ int b = (n+1);
+ for (int j = 0; j < n; j++) {
+ for (int i = 0; i < n; i++) {
+ M[i][j] = n*((i+j+a) % n) + ((i+2*j+b) % n) + 1;
+ }
+ }
+
+ // Doubly Even Order
+
+ } else if ((n % 4) == 0) {
+ for (int j = 0; j < n; j++) {
+ for (int i = 0; i < n; i++) {
+ if (((i+1)/2)%2 == ((j+1)/2)%2) {
+ M[i][j] = n*n-n*i-j;
+ } else {
+ M[i][j] = n*i+j+1;
+ }
+ }
+ }
+
+ // Singly Even Order
+
+ } else {
+ int p = n/2;
+ int k = (n-2)/4;
+ Matrix A = magic(p);
+ for (int j = 0; j < p; j++) {
+ for (int i = 0; i < p; i++) {
+ double aij = A.get(i,j);
+ M[i][j] = aij;
+ M[i][j+p] = aij + 2*p*p;
+ M[i+p][j] = aij + 3*p*p;
+ M[i+p][j+p] = aij + p*p;
+ }
+ }
+ for (int i = 0; i < p; i++) {
+ for (int j = 0; j < k; j++) {
+ double t = M[i][j]; M[i][j] = M[i+p][j]; M[i+p][j] = t;
+ }
+ for (int j = n-k+1; j < n; j++) {
+ double t = M[i][j]; M[i][j] = M[i+p][j]; M[i+p][j] = t;
+ }
+ }
+ double t = M[k][0]; M[k][0] = M[k+p][0]; M[k+p][0] = t;
+ t = M[k][k]; M[k][k] = M[k+p][k]; M[k+p][k] = t;
+ }
+ return new Matrix(M);
+ }
+
+ /** Shorten spelling of print. **/
+
+ private static void print (String s) {
+ System.out.print(s);
+ }
+
+ /** Format double with Fw.d. **/
+
+ public static String fixedWidthDoubletoString (double x, int w, int d) {
+ java.text.DecimalFormat fmt = new java.text.DecimalFormat();
+ fmt.setMaximumFractionDigits(d);
+ fmt.setMinimumFractionDigits(d);
+ fmt.setGroupingUsed(false);
+ String s = fmt.format(x);
+ while (s.length() < w) {
+ s = " " + s;
+ }
+ return s;
+ }
+
+ /** Format integer with Iw. **/
+
+ public static String fixedWidthIntegertoString (int n, int w) {
+ String s = Integer.toString(n);
+ while (s.length() < w) {
+ s = " " + s;
+ }
+ return s;
+ }
+
+
+ public static void main (String argv[]) {
+
+ /*
+ | Tests LU, QR, SVD and symmetric Eig decompositions.
+ |
+ | n = order of magic square.
+ | trace = diagonal sum, should be the magic sum, (n^3 + n)/2.
+ | max_eig = maximum eigenvalue of (A + A')/2, should equal trace.
+ | rank = linear algebraic rank,
+ | should equal n if n is odd, be less than n if n is even.
+ | cond = L_2 condition number, ratio of singular values.
+ | lu_res = test of LU factorization, norm1(L*U-A(p,:))/(n*eps).
+ | qr_res = test of QR factorization, norm1(Q*R-A)/(n*eps).
+ */
+
+ print("\n Test of Matrix Class, using magic squares.\n");
+ print(" See MagicSquareExample.main() for an explanation.\n");
+ print("\n n trace max_eig rank cond lu_res qr_res\n\n");
+
+ Date start_time = new Date();
+ double eps = Math.pow(2.0,-52.0);
+ for (int n = 3; n <= 32; n++) {
+ print(fixedWidthIntegertoString(n,7));
+
+ Matrix M = magic(n);
+
+ int t = (int) M.trace();
+ print(fixedWidthIntegertoString(t,10));
+
+ EigenvalueDecomposition E =
+ new EigenvalueDecomposition(M.plus(M.transpose()).times(0.5));
+ double[] d = E.getRealEigenvalues();
+ print(fixedWidthDoubletoString(d[n-1],14,3));
+
+ int r = M.rank();
+ print(fixedWidthIntegertoString(r,7));
+
+ double c = M.cond();
+ print(c < 1/eps ? fixedWidthDoubletoString(c,12,3) :
+ " Inf");
+
+ LUDecomposition LU = new LUDecomposition(M);
+ Matrix L = LU.getL();
+ Matrix U = LU.getU();
+ int[] p = LU.getPivot();
+ Matrix R = L.times(U).minus(M.getMatrix(p,0,n-1));
+ double res = R.norm1()/(n*eps);
+ print(fixedWidthDoubletoString(res,12,3));
+
+ QRDecomposition QR = new QRDecomposition(M);
+ Matrix Q = QR.getQ();
+ R = QR.getR();
+ R = Q.times(R).minus(M);
+ res = R.norm1()/(n*eps);
+ print(fixedWidthDoubletoString(res,12,3));
+
+ print("\n");
+ }
+ Date stop_time = new Date();
+ double etime = (stop_time.getTime() - start_time.getTime())/1000.;
+ print("\nElapsed Time = " +
+ fixedWidthDoubletoString(etime,12,3) + " seconds\n");
+ print("Adios\n");
+ }
+}
diff --git a/Java/src/Jama/test/TestMatrix.java b/Java/src/Jama/test/TestMatrix.java
new file mode 100644
index 00000000..d08ca2c4
--- /dev/null
+++ b/Java/src/Jama/test/TestMatrix.java
@@ -0,0 +1,957 @@
+package Jama.test;
+import Jama.*;
+import java.io.*;
+import java.util.zip.GZIPInputStream;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.Locale;
+
+/** TestMatrix tests the functionality of the Jama Matrix class and associated decompositions.
+
+Run the test from the command line using
+
+ java Jama.test.TestMatrix
+
+Detailed output is provided indicating the functionality being tested
+and whether the functionality is correctly implemented. Exception handling
+is also tested.
+
+The test is designed to run to completion and give a summary of any implementation errors
+encountered. The final output should be:
+
+ TestMatrix completed.
+ Total errors reported: n1
+ Total warning reported: n2
+
+If the test does not run to completion, this indicates that there is a
+substantial problem within the implementation that was not anticipated in the test design.
+The stopping point should give an indication of where the problem exists.
+**/
+public class TestMatrix {
+ public static void main (String argv[]) {
+ Matrix A,B,C,Z,O,I,R,S,X,SUB,M,T,SQ,DEF,SOL;
+ // Uncomment this to test IO in a different locale.
+ // Locale.setDefault(Locale.GERMAN);
+ int errorCount=0;
+ int warningCount=0;
+ double tmp, s;
+ double[] columnwise = {1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.};
+ double[] rowwise = {1.,4.,7.,10.,2.,5.,8.,11.,3.,6.,9.,12.};
+ double[][] avals = {{1.,4.,7.,10.},{2.,5.,8.,11.},{3.,6.,9.,12.}};
+ double[][] rankdef = avals;
+ double[][] tvals = {{1.,2.,3.},{4.,5.,6.},{7.,8.,9.},{10.,11.,12.}};
+ double[][] subavals = {{5.,8.,11.},{6.,9.,12.}};
+ double[][] rvals = {{1.,4.,7.},{2.,5.,8.,11.},{3.,6.,9.,12.}};
+ double[][] pvals = {{4.,1.,1.},{1.,2.,3.},{1.,3.,6.}};
+ double[][] ivals = {{1.,0.,0.,0.},{0.,1.,0.,0.},{0.,0.,1.,0.}};
+ double[][] evals =
+ {{0.,1.,0.,0.},{1.,0.,2.e-7,0.},{0.,-2.e-7,0.,1.},{0.,0.,1.,0.}};
+ double[][] square = {{166.,188.,210.},{188.,214.,240.},{210.,240.,270.}};
+ double[][] sqSolution = {{13.},{15.}};
+ double[][] condmat = {{1.,3.},{7.,9.}};
+ double[][] badeigs = {{0,0,0,0,0}, {0,0,0,0,1},{0,0,0,1,0},
+ {1,1,0,0,1},{1,0,1,0,1}};
+ int rows=3,cols=4;
+ int invalidld=5;/* should trigger bad shape for construction with val */
+ int raggedr=0; /* (raggedr,raggedc) should be out of bounds in ragged array */
+ int raggedc=4;
+ int validld=3; /* leading dimension of intended test Matrices */
+ int nonconformld=4; /* leading dimension which is valid, but nonconforming */
+ int ib=1,ie=2,jb=1,je=3; /* index ranges for sub Matrix */
+ int[] rowindexset = {1,2};
+ int[] badrowindexset = {1,3};
+ int[] columnindexset = {1,2,3};
+ int[] badcolumnindexset = {1,2,4};
+ double columnsummax = 33.;
+ double rowsummax = 30.;
+ double sumofdiagonals = 15;
+ double sumofsquares = 650;
+
+/**
+ Constructors and constructor-like methods:
+ double[], int
+ double[][]
+ int, int
+ int, int, double
+ int, int, double[][]
+ constructWithCopy(double[][])
+ random(int,int)
+ identity(int)
+**/
+
+ print("\nTesting constructors and constructor-like methods...\n");
+ try{
+ /** check that exception is thrown in packed constructor with invalid length **/
+ A = new Matrix(columnwise,invalidld);
+ errorCount = try_failure(errorCount,"Catch invalid length in packed constructor... ",
+ "exception not thrown for invalid input");
+ } catch ( IllegalArgumentException e ) {
+ try_success("Catch invalid length in packed constructor... ",
+ e.getMessage());
+ }
+ try{
+ /** check that exception is thrown in default constructor
+ if input array is 'ragged' **/
+ A = new Matrix(rvals);
+ tmp = A.get(raggedr,raggedc);
+ } catch ( IllegalArgumentException e ) {
+ try_success("Catch ragged input to default constructor... ",
+ e.getMessage());
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ errorCount = try_failure(errorCount,"Catch ragged input to constructor... ",
+ "exception not thrown in construction...ArrayIndexOutOfBoundsException thrown later");
+ }
+ try{
+ /** check that exception is thrown in constructWithCopy
+ if input array is 'ragged' **/
+ A = Matrix.constructWithCopy(rvals);
+ tmp = A.get(raggedr,raggedc);
+ } catch ( IllegalArgumentException e ) {
+ try_success("Catch ragged input to constructWithCopy... ",e.getMessage());
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ errorCount = try_failure(errorCount,"Catch ragged input to constructWithCopy... ","exception not thrown in construction...ArrayIndexOutOfBoundsException thrown later");
+ }
+
+ A = new Matrix(columnwise,validld);
+ B = new Matrix(avals);
+ tmp = B.get(0,0);
+ avals[0][0] = 0.0;
+ C = B.minus(A);
+ avals[0][0] = tmp;
+ B = Matrix.constructWithCopy(avals);
+ tmp = B.get(0,0);
+ avals[0][0] = 0.0;
+ if ( ( tmp - B.get(0,0) ) != 0.0 ) {
+ /** check that constructWithCopy behaves properly **/
+ errorCount = try_failure(errorCount,"constructWithCopy... ","copy not effected... data visible outside");
+ } else {
+ try_success("constructWithCopy... ","");
+ }
+ avals[0][0] = columnwise[0];
+ I = new Matrix(ivals);
+ try {
+ check(I,Matrix.identity(3,4));
+ try_success("identity... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"identity... ","identity Matrix not successfully created");
+ }
+
+/**
+ Access Methods:
+ getColumnDimension()
+ getRowDimension()
+ getArray()
+ getArrayCopy()
+ getColumnPackedCopy()
+ getRowPackedCopy()
+ get(int,int)
+ getMatrix(int,int,int,int)
+ getMatrix(int,int,int[])
+ getMatrix(int[],int,int)
+ getMatrix(int[],int[])
+ set(int,int,double)
+ setMatrix(int,int,int,int,Matrix)
+ setMatrix(int,int,int[],Matrix)
+ setMatrix(int[],int,int,Matrix)
+ setMatrix(int[],int[],Matrix)
+**/
+
+ print("\nTesting access methods...\n");
+
+/**
+ Various get methods:
+**/
+
+ B = new Matrix(avals);
+ if (B.getRowDimension() != rows) {
+ errorCount = try_failure(errorCount,"getRowDimension... ","");
+ } else {
+ try_success("getRowDimension... ","");
+ }
+ if (B.getColumnDimension() != cols) {
+ errorCount = try_failure(errorCount,"getColumnDimension... ","");
+ } else {
+ try_success("getColumnDimension... ","");
+ }
+ B = new Matrix(avals);
+ double[][] barray = B.getArray();
+ if ( barray != avals ) {
+ errorCount = try_failure(errorCount,"getArray... ","");
+ } else {
+ try_success("getArray... ","");
+ }
+ barray = B.getArrayCopy();
+ if ( barray == avals ) {
+ errorCount = try_failure(errorCount,"getArrayCopy... ","data not (deep) copied");
+ }
+ try {
+ check(barray,avals);
+ try_success("getArrayCopy... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"getArrayCopy... ","data not successfully (deep) copied");
+ }
+ double[] bpacked = B.getColumnPackedCopy();
+ try {
+ check(bpacked,columnwise);
+ try_success("getColumnPackedCopy... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"getColumnPackedCopy... ","data not successfully (deep) copied by columns");
+ }
+ bpacked = B.getRowPackedCopy();
+ try {
+ check(bpacked,rowwise);
+ try_success("getRowPackedCopy... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"getRowPackedCopy... ","data not successfully (deep) copied by rows");
+ }
+ try {
+ tmp = B.get(B.getRowDimension(),B.getColumnDimension()-1);
+ errorCount = try_failure(errorCount,"get(int,int)... ","OutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ tmp = B.get(B.getRowDimension()-1,B.getColumnDimension());
+ errorCount = try_failure(errorCount,"get(int,int)... ","OutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("get(int,int)... OutofBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"get(int,int)... ","OutOfBoundsException expected but not thrown");
+ }
+ try {
+ if (B.get(B.getRowDimension()-1,B.getColumnDimension()-1) !=
+ avals[B.getRowDimension()-1][B.getColumnDimension()-1] ) {
+ errorCount = try_failure(errorCount,"get(int,int)... ","Matrix entry (i,j) not successfully retreived");
+ } else {
+ try_success("get(int,int)... ","");
+ }
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ errorCount = try_failure(errorCount,"get(int,int)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+ SUB = new Matrix(subavals);
+ try {
+ M = B.getMatrix(ib,ie+B.getRowDimension()+1,jb,je);
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int,int)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ M = B.getMatrix(ib,ie,jb,je+B.getColumnDimension()+1);
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int,int)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("getMatrix(int,int,int,int)... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int,int)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ M = B.getMatrix(ib,ie,jb,je);
+ try {
+ check(SUB,M);
+ try_success("getMatrix(int,int,int,int)... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int,int)... ","submatrix not successfully retreived");
+ }
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int,int)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+
+ try {
+ M = B.getMatrix(ib,ie,badcolumnindexset);
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int[])... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ M = B.getMatrix(ib,ie+B.getRowDimension()+1,columnindexset);
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int[])... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("getMatrix(int,int,int[])... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int[])... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ M = B.getMatrix(ib,ie,columnindexset);
+ try {
+ check(SUB,M);
+ try_success("getMatrix(int,int,int[])... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int[])... ","submatrix not successfully retreived");
+ }
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int,int,int[])... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+ try {
+ M = B.getMatrix(badrowindexset,jb,je);
+ errorCount = try_failure(errorCount,"getMatrix(int[],int,int)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ M = B.getMatrix(rowindexset,jb,je+B.getColumnDimension()+1);
+ errorCount = try_failure(errorCount,"getMatrix(int[],int,int)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("getMatrix(int[],int,int)... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"getMatrix(int[],int,int)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ M = B.getMatrix(rowindexset,jb,je);
+ try {
+ check(SUB,M);
+ try_success("getMatrix(int[],int,int)... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int[],int,int)... ","submatrix not successfully retreived");
+ }
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int[],int,int)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+ try {
+ M = B.getMatrix(badrowindexset,columnindexset);
+ errorCount = try_failure(errorCount,"getMatrix(int[],int[])... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ M = B.getMatrix(rowindexset,badcolumnindexset);
+ errorCount = try_failure(errorCount,"getMatrix(int[],int[])... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("getMatrix(int[],int[])... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"getMatrix(int[],int[])... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ M = B.getMatrix(rowindexset,columnindexset);
+ try {
+ check(SUB,M);
+ try_success("getMatrix(int[],int[])... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int[],int[])... ","submatrix not successfully retreived");
+ }
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ errorCount = try_failure(errorCount,"getMatrix(int[],int[])... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+
+/**
+ Various set methods:
+**/
+
+ try {
+ B.set(B.getRowDimension(),B.getColumnDimension()-1,0.);
+ errorCount = try_failure(errorCount,"set(int,int,double)... ","OutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ B.set(B.getRowDimension()-1,B.getColumnDimension(),0.);
+ errorCount = try_failure(errorCount,"set(int,int,double)... ","OutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("set(int,int,double)... OutofBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"set(int,int,double)... ","OutOfBoundsException expected but not thrown");
+ }
+ try {
+ B.set(ib,jb,0.);
+ tmp = B.get(ib,jb);
+ try {
+ check(tmp,0.);
+ try_success("set(int,int,double)... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"set(int,int,double)... ","Matrix element not successfully set");
+ }
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1) {
+ errorCount = try_failure(errorCount,"set(int,int,double)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+ M = new Matrix(2,3,0.);
+ try {
+ B.setMatrix(ib,ie+B.getRowDimension()+1,jb,je,M);
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int,int,Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ B.setMatrix(ib,ie,jb,je+B.getColumnDimension()+1,M);
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int,int,Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("setMatrix(int,int,int,int,Matrix)... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int,int,Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ B.setMatrix(ib,ie,jb,je,M);
+ try {
+ check(M.minus(B.getMatrix(ib,ie,jb,je)),M);
+ try_success("setMatrix(int,int,int,int,Matrix)... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int,int,Matrix)... ","submatrix not successfully set");
+ }
+ B.setMatrix(ib,ie,jb,je,SUB);
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int,int,Matrix)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+ try {
+ B.setMatrix(ib,ie+B.getRowDimension()+1,columnindexset,M);
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int[],Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ B.setMatrix(ib,ie,badcolumnindexset,M);
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int[],Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("setMatrix(int,int,int[],Matrix)... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int[],Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ B.setMatrix(ib,ie,columnindexset,M);
+ try {
+ check(M.minus(B.getMatrix(ib,ie,columnindexset)),M);
+ try_success("setMatrix(int,int,int[],Matrix)... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int[],Matrix)... ","submatrix not successfully set");
+ }
+ B.setMatrix(ib,ie,jb,je,SUB);
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int,int,int[],Matrix)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+ try {
+ B.setMatrix(rowindexset,jb,je+B.getColumnDimension()+1,M);
+ errorCount = try_failure(errorCount,"setMatrix(int[],int,int,Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ B.setMatrix(badrowindexset,jb,je,M);
+ errorCount = try_failure(errorCount,"setMatrix(int[],int,int,Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("setMatrix(int[],int,int,Matrix)... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int[],int,int,Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ B.setMatrix(rowindexset,jb,je,M);
+ try {
+ check(M.minus(B.getMatrix(rowindexset,jb,je)),M);
+ try_success("setMatrix(int[],int,int,Matrix)... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"setMatrix(int[],int,int,Matrix)... ","submatrix not successfully set");
+ }
+ B.setMatrix(ib,ie,jb,je,SUB);
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int[],int,int,Matrix)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+ try {
+ B.setMatrix(rowindexset,badcolumnindexset,M);
+ errorCount = try_failure(errorCount,"setMatrix(int[],int[],Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e ) {
+ try {
+ B.setMatrix(badrowindexset,columnindexset,M);
+ errorCount = try_failure(errorCount,"setMatrix(int[],int[],Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ try_success("setMatrix(int[],int[],Matrix)... ArrayIndexOutOfBoundsException... ","");
+ }
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int[],int[],Matrix)... ","ArrayIndexOutOfBoundsException expected but not thrown");
+ }
+ try {
+ B.setMatrix(rowindexset,columnindexset,M);
+ try {
+ check(M.minus(B.getMatrix(rowindexset,columnindexset)),M);
+ try_success("setMatrix(int[],int[],Matrix)... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"setMatrix(int[],int[],Matrix)... ","submatrix not successfully set");
+ }
+ } catch ( java.lang.ArrayIndexOutOfBoundsException e1 ) {
+ errorCount = try_failure(errorCount,"setMatrix(int[],int[],Matrix)... ","Unexpected ArrayIndexOutOfBoundsException");
+ }
+
+/**
+ Array-like methods:
+ minus
+ minusEquals
+ plus
+ plusEquals
+ arrayLeftDivide
+ arrayLeftDivideEquals
+ arrayRightDivide
+ arrayRightDivideEquals
+ arrayTimes
+ arrayTimesEquals
+ uminus
+**/
+
+ print("\nTesting array-like methods...\n");
+ S = new Matrix(columnwise,nonconformld);
+ R = Matrix.random(A.getRowDimension(),A.getColumnDimension());
+ A = R;
+ try {
+ S = A.minus(S);
+ errorCount = try_failure(errorCount,"minus conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("minus conformance check... ","");
+ }
+ if (A.minus(R).norm1() != 0.) {
+ errorCount = try_failure(errorCount,"minus... ","(difference of identical Matrices is nonzero,\nSubsequent use of minus should be suspect)");
+ } else {
+ try_success("minus... ","");
+ }
+ A = R.copy();
+ A.minusEquals(R);
+ Z = new Matrix(A.getRowDimension(),A.getColumnDimension());
+ try {
+ A.minusEquals(S);
+ errorCount = try_failure(errorCount,"minusEquals conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("minusEquals conformance check... ","");
+ }
+ if (A.minus(Z).norm1() != 0.) {
+ errorCount = try_failure(errorCount,"minusEquals... ","(difference of identical Matrices is nonzero,\nSubsequent use of minus should be suspect)");
+ } else {
+ try_success("minusEquals... ","");
+ }
+
+ A = R.copy();
+ B = Matrix.random(A.getRowDimension(),A.getColumnDimension());
+ C = A.minus(B);
+ try {
+ S = A.plus(S);
+ errorCount = try_failure(errorCount,"plus conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("plus conformance check... ","");
+ }
+ try {
+ check(C.plus(B),A);
+ try_success("plus... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"plus... ","(C = A - B, but C + B != A)");
+ }
+ C = A.minus(B);
+ C.plusEquals(B);
+ try {
+ A.plusEquals(S);
+ errorCount = try_failure(errorCount,"plusEquals conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("plusEquals conformance check... ","");
+ }
+ try {
+ check(C,A);
+ try_success("plusEquals... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"plusEquals... ","(C = A - B, but C = C + B != A)");
+ }
+ A = R.uminus();
+ try {
+ check(A.plus(R),Z);
+ try_success("uminus... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"uminus... ","(-A + A != zeros)");
+ }
+ A = R.copy();
+ O = new Matrix(A.getRowDimension(),A.getColumnDimension(),1.0);
+ C = A.arrayLeftDivide(R);
+ try {
+ S = A.arrayLeftDivide(S);
+ errorCount = try_failure(errorCount,"arrayLeftDivide conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("arrayLeftDivide conformance check... ","");
+ }
+ try {
+ check(C,O);
+ try_success("arrayLeftDivide... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"arrayLeftDivide... ","(M.\\M != ones)");
+ }
+ try {
+ A.arrayLeftDivideEquals(S);
+ errorCount = try_failure(errorCount,"arrayLeftDivideEquals conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("arrayLeftDivideEquals conformance check... ","");
+ }
+ A.arrayLeftDivideEquals(R);
+ try {
+ check(A,O);
+ try_success("arrayLeftDivideEquals... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"arrayLeftDivideEquals... ","(M.\\M != ones)");
+ }
+ A = R.copy();
+ try {
+ A.arrayRightDivide(S);
+ errorCount = try_failure(errorCount,"arrayRightDivide conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("arrayRightDivide conformance check... ","");
+ }
+ C = A.arrayRightDivide(R);
+ try {
+ check(C,O);
+ try_success("arrayRightDivide... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"arrayRightDivide... ","(M./M != ones)");
+ }
+ try {
+ A.arrayRightDivideEquals(S);
+ errorCount = try_failure(errorCount,"arrayRightDivideEquals conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("arrayRightDivideEquals conformance check... ","");
+ }
+ A.arrayRightDivideEquals(R);
+ try {
+ check(A,O);
+ try_success("arrayRightDivideEquals... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"arrayRightDivideEquals... ","(M./M != ones)");
+ }
+ A = R.copy();
+ B = Matrix.random(A.getRowDimension(),A.getColumnDimension());
+ try {
+ S = A.arrayTimes(S);
+ errorCount = try_failure(errorCount,"arrayTimes conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("arrayTimes conformance check... ","");
+ }
+ C = A.arrayTimes(B);
+ try {
+ check(C.arrayRightDivideEquals(B),A);
+ try_success("arrayTimes... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"arrayTimes... ","(A = R, C = A.*B, but C./B != A)");
+ }
+ try {
+ A.arrayTimesEquals(S);
+ errorCount = try_failure(errorCount,"arrayTimesEquals conformance check... ","nonconformance not raised");
+ } catch ( IllegalArgumentException e ) {
+ try_success("arrayTimesEquals conformance check... ","");
+ }
+ A.arrayTimesEquals(B);
+ try {
+ check(A.arrayRightDivideEquals(B),R);
+ try_success("arrayTimesEquals... ","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"arrayTimesEquals... ","(A = R, A = A.*B, but A./B != R)");
+ }
+
+/**
+ I/O methods:
+ read
+ print
+ serializable:
+ writeObject
+ readObject
+**/
+ print("\nTesting I/O methods...\n");
+ try {
+ DecimalFormat fmt = new DecimalFormat("0.0000E00");
+ fmt.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US));
+
+ PrintWriter FILE = new PrintWriter(new FileOutputStream("JamaTestMatrix.out"));
+ A.print(FILE,fmt,10);
+ FILE.close();
+ R = Matrix.read(new BufferedReader(new FileReader("JamaTestMatrix.out")));
+ if (A.minus(R).norm1() < .001 ) {
+ try_success("print()/read()...","");
+ } else {
+ errorCount = try_failure(errorCount,"print()/read()...","Matrix read from file does not match Matrix printed to file");
+ }
+ } catch ( java.io.IOException ioe ) {
+ warningCount = try_warning(warningCount,"print()/read()...","unexpected I/O error, unable to run print/read test; check write permission in current directory and retry");
+ } catch(Exception e) {
+ try {
+ e.printStackTrace(System.out);
+ warningCount = try_warning(warningCount,"print()/read()...","Formatting error... will try JDK1.1 reformulation...");
+ DecimalFormat fmt = new DecimalFormat("0.0000");
+ PrintWriter FILE = new PrintWriter(new FileOutputStream("JamaTestMatrix.out"));
+ A.print(FILE,fmt,10);
+ FILE.close();
+ R = Matrix.read(new BufferedReader(new FileReader("JamaTestMatrix.out")));
+ if (A.minus(R).norm1() < .001 ) {
+ try_success("print()/read()...","");
+ } else {
+ errorCount = try_failure(errorCount,"print()/read() (2nd attempt) ...","Matrix read from file does not match Matrix printed to file");
+ }
+ } catch ( java.io.IOException ioe ) {
+ warningCount = try_warning(warningCount,"print()/read()...","unexpected I/O error, unable to run print/read test; check write permission in current directory and retry");
+ }
+ }
+
+ R = Matrix.random(A.getRowDimension(),A.getColumnDimension());
+ String tmpname = "TMPMATRIX.serial";
+ try {
+ ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(tmpname));
+ out.writeObject(R);
+ ObjectInputStream sin = new ObjectInputStream(new FileInputStream(tmpname));
+ A = (Matrix) sin.readObject();
+
+ try {
+ check(A,R);
+ try_success("writeObject(Matrix)/readObject(Matrix)...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"writeObject(Matrix)/readObject(Matrix)...","Matrix not serialized correctly");
+ }
+ } catch ( java.io.IOException ioe ) {
+ warningCount = try_warning(warningCount,"writeObject()/readObject()...","unexpected I/O error, unable to run serialization test; check write permission in current directory and retry");
+ } catch(Exception e) {
+ errorCount = try_failure(errorCount,"writeObject(Matrix)/readObject(Matrix)...","unexpected error in serialization test");
+ }
+
+/**
+ LA methods:
+ transpose
+ times
+ cond
+ rank
+ det
+ trace
+ norm1
+ norm2
+ normF
+ normInf
+ solve
+ solveTranspose
+ inverse
+ chol
+ eig
+ lu
+ qr
+ svd
+**/
+
+ print("\nTesting linear algebra methods...\n");
+ A = new Matrix(columnwise,3);
+ T = new Matrix(tvals);
+ T = A.transpose();
+ try {
+ check(A.transpose(),T);
+ try_success("transpose...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"transpose()...","transpose unsuccessful");
+ }
+ A.transpose();
+ try {
+ check(A.norm1(),columnsummax);
+ try_success("norm1...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"norm1()...","incorrect norm calculation");
+ }
+ try {
+ check(A.normInf(),rowsummax);
+ try_success("normInf()...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"normInf()...","incorrect norm calculation");
+ }
+ try {
+ check(A.normF(),Math.sqrt(sumofsquares));
+ try_success("normF...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"normF()...","incorrect norm calculation");
+ }
+ try {
+ check(A.trace(),sumofdiagonals);
+ try_success("trace()...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"trace()...","incorrect trace calculation");
+ }
+ try {
+ check(A.getMatrix(0,A.getRowDimension()-1,0,A.getRowDimension()-1).det(),0.);
+ try_success("det()...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"det()...","incorrect determinant calculation");
+ }
+ SQ = new Matrix(square);
+ try {
+ check(A.times(A.transpose()),SQ);
+ try_success("times(Matrix)...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"times(Matrix)...","incorrect Matrix-Matrix product calculation");
+ }
+ try {
+ check(A.times(0.),Z);
+ try_success("times(double)...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"times(double)...","incorrect Matrix-scalar product calculation");
+ }
+
+ A = new Matrix(columnwise,4);
+ QRDecomposition QR = A.qr();
+ R = QR.getR();
+ try {
+ check(A,QR.getQ().times(R));
+ try_success("QRDecomposition...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"QRDecomposition...","incorrect QR decomposition calculation");
+ }
+ SingularValueDecomposition SVD = A.svd();
+ try {
+ check(A,SVD.getU().times(SVD.getS().times(SVD.getV().transpose())));
+ try_success("SingularValueDecomposition...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"SingularValueDecomposition...","incorrect singular value decomposition calculation");
+ }
+ DEF = new Matrix(rankdef);
+ try {
+ check(DEF.rank(),Math.min(DEF.getRowDimension(),DEF.getColumnDimension())-1);
+ try_success("rank()...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"rank()...","incorrect rank calculation");
+ }
+ B = new Matrix(condmat);
+ SVD = B.svd();
+ double [] singularvalues = SVD.getSingularValues();
+ try {
+ check(B.cond(),singularvalues[0]/singularvalues[Math.min(B.getRowDimension(),B.getColumnDimension())-1]);
+ try_success("cond()...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"cond()...","incorrect condition number calculation");
+ }
+ int n = A.getColumnDimension();
+ A = A.getMatrix(0,n-1,0,n-1);
+ A.set(0,0,0.);
+ LUDecomposition LU = A.lu();
+ try {
+ check(A.getMatrix(LU.getPivot(),0,n-1),LU.getL().times(LU.getU()));
+ try_success("LUDecomposition...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"LUDecomposition...","incorrect LU decomposition calculation");
+ }
+ X = A.inverse();
+ try {
+ check(A.times(X),Matrix.identity(3,3));
+ try_success("inverse()...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"inverse()...","incorrect inverse calculation");
+ }
+ O = new Matrix(SUB.getRowDimension(),1,1.0);
+ SOL = new Matrix(sqSolution);
+ SQ = SUB.getMatrix(0,SUB.getRowDimension()-1,0,SUB.getRowDimension()-1);
+ try {
+ check(SQ.solve(SOL),O);
+ try_success("solve()...","");
+ } catch ( java.lang.IllegalArgumentException e1 ) {
+ errorCount = try_failure(errorCount,"solve()...",e1.getMessage());
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"solve()...",e.getMessage());
+ }
+ A = new Matrix(pvals);
+ CholeskyDecomposition Chol = A.chol();
+ Matrix L = Chol.getL();
+ try {
+ check(A,L.times(L.transpose()));
+ try_success("CholeskyDecomposition...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"CholeskyDecomposition...","incorrect Cholesky decomposition calculation");
+ }
+ X = Chol.solve(Matrix.identity(3,3));
+ try {
+ check(A.times(X),Matrix.identity(3,3));
+ try_success("CholeskyDecomposition solve()...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"CholeskyDecomposition solve()...","incorrect Choleskydecomposition solve calculation");
+ }
+ EigenvalueDecomposition Eig = A.eig();
+ Matrix D = Eig.getD();
+ Matrix V = Eig.getV();
+ try {
+ check(A.times(V),V.times(D));
+ try_success("EigenvalueDecomposition (symmetric)...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"EigenvalueDecomposition (symmetric)...","incorrect symmetric Eigenvalue decomposition calculation");
+ }
+ A = new Matrix(evals);
+ Eig = A.eig();
+ D = Eig.getD();
+ V = Eig.getV();
+ try {
+ check(A.times(V),V.times(D));
+ try_success("EigenvalueDecomposition (nonsymmetric)...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"EigenvalueDecomposition (nonsymmetric)...","incorrect nonsymmetric Eigenvalue decomposition calculation");
+ }
+
+ try {
+ print("\nTesting Eigenvalue; If this hangs, we've failed\n");
+ Matrix bA = new Matrix(badeigs);
+ EigenvalueDecomposition bEig = bA.eig();
+ try_success("EigenvalueDecomposition (hang)...","");
+ } catch ( java.lang.RuntimeException e ) {
+ errorCount = try_failure(errorCount,"EigenvalueDecomposition (hang)...",
+ "incorrect termination");
+ }
+
+
+ print("\nTestMatrix completed.\n");
+ print("Total errors reported: " + Integer.toString(errorCount) + "\n");
+ print("Total warnings reported: " + Integer.toString(warningCount) + "\n");
+ }
+
+ /** private utility routines **/
+
+ /** Check magnitude of difference of scalars. **/
+
+ private static void check(double x, double y) {
+ double eps = Math.pow(2.0,-52.0);
+ if (x == 0 & Math.abs(y) < 10*eps) return;
+ if (y == 0 & Math.abs(x) < 10*eps) return;
+ if (Math.abs(x-y) > 10*eps*Math.max(Math.abs(x),Math.abs(y))) {
+ throw new RuntimeException("The difference x-y is too large: x = " + Double.toString(x) + " y = " + Double.toString(y));
+ }
+ }
+
+ /** Check norm of difference of "vectors". **/
+
+ private static void check(double[] x, double[] y) {
+ if (x.length == y.length ) {
+ for (int i=0;i 1000*eps*Math.max(X.norm1(),Y.norm1())) {
+ throw new RuntimeException("The norm of (X-Y) is too large: " + Double.toString(X.minus(Y).norm1()));
+ }
+ }
+
+ /** Shorten spelling of print. **/
+
+ private static void print (String s) {
+ System.out.print(s);
+ }
+
+ /** Print appropriate messages for successful outcome try **/
+
+ private static void try_success (String s,String e) {
+ print("> " + s + "success\n");
+ if ( e != "" ) {
+ print("> Message: " + e + "\n");
+ }
+ }
+ /** Print appropriate messages for unsuccessful outcome try **/
+
+ private static int try_failure (int count, String s,String e) {
+ print("> " + s + "*** failure ***\n> Message: " + e + "\n");
+ return ++count;
+ }
+
+ /** Print appropriate messages for unsuccessful outcome try **/
+
+ private static int try_warning (int count, String s,String e) {
+ print("> " + s + "*** warning ***\n> Message: " + e + "\n");
+ return ++count;
+ }
+
+ /** Print a row vector. **/
+
+ private static void print(double[] x, int w, int d) {
+ // Use format Fw.d for all elements.
+ System.out.print("\n");
+ new Matrix(x,1).print(w,d);
+ print("\n");
+ }
+
+}
diff --git a/Java/src/Jama/util/Maths.java b/Java/src/Jama/util/Maths.java
new file mode 100644
index 00000000..087a6a74
--- /dev/null
+++ b/Java/src/Jama/util/Maths.java
@@ -0,0 +1,20 @@
+package Jama.util;
+
+public class Maths {
+
+ /** sqrt(a^2 + b^2) without under/overflow. **/
+
+ public static double hypot(double a, double b) {
+ double r;
+ if (Math.abs(a) > Math.abs(b)) {
+ r = b/a;
+ r = Math.abs(a)*Math.sqrt(1+r*r);
+ } else if (b != 0) {
+ r = a/b;
+ r = Math.abs(b)*Math.sqrt(1+r*r);
+ } else {
+ r = 0.0;
+ }
+ return r;
+ }
+}
diff --git a/Java/src/Viewer2D/EdgesFrame.java b/Java/src/Viewer2D/EdgesFrame.java
index b73c609c..0cde000c 100755
--- a/Java/src/Viewer2D/EdgesFrame.java
+++ b/Java/src/Viewer2D/EdgesFrame.java
@@ -21,22 +21,32 @@
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
+import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Graphics;
+import java.awt.Image;
+import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
+import java.awt.event.KeyListener;
+import java.awt.event.ComponentListener;
+import java.awt.event.ComponentEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.InputEvent;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
+import javax.swing.AbstractAction;
import javax.swing.JButton;
import javax.swing.JColorChooser;
+import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
@@ -44,10 +54,15 @@
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
import javax.swing.JRadioButton;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
+import javax.swing.JToggleButton;
+import javax.swing.KeyStroke;
+
+import Viewer2D.EdgesPanel.modes;
/**
* SESS - 2014.05.11:
@@ -66,7 +81,7 @@
// TODO: SESS - Also show "working, please wait..."
// TODO: SESS - When edges panel should repaint is repainting this frame
// should be only the edges panel
-public class EdgesFrame extends JFrame {
+public class EdgesFrame extends JFrame implements KeyListener,ComponentListener {
private static final long serialVersionUID = 1099866981814538683L;
static final int FRAME_WIDTH = 1024;
@@ -75,6 +90,10 @@ public class EdgesFrame extends JFrame {
private Edge[] edges;
private Vertex[] vertices;
+ private HashMap labels;
+
+ private double labelScale;
+
private EdgesPanel panel; // Has the edges drawn
private JTextField statusBar; // Shows highlighted/user info
@@ -119,6 +138,11 @@ public class EdgesFrame extends JFrame {
private Color fontColor, vertexColor, edgeColor, backgroundColor;
private int STATUSBAR_Y;
+
+
+ JToggleButton hand;
+
+ JToggleButton magnifier;
public EdgesFrame(String title, int x, int y) {
super(title);
@@ -128,7 +152,7 @@ public EdgesFrame(String title, int x, int y) {
STATUSBAR_Y = 50;
moveStepSize = .2;
- zoomStepSize = .2;
+ zoomStepSize = .8;
windowSizes = new int[2];
windowSizes[0] = x;
@@ -147,12 +171,16 @@ public EdgesFrame(String title, int x, int y) {
container.setLayout(layout);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
- panel = new EdgesPanel(edges, vertices, windowSizes[0], windowSizes[1]);
+ Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
+ panel = new EdgesPanel(edges, vertices, new HashMap(),screen.width,screen.height);//windowSizes[0], windowSizes[1]);
panel.setBackground(backgroundColor);
setMenuBars();
+ hand = new JToggleButton("Hand");
+ magnifier = new JToggleButton("Magnifier");
setButtons();
+
+ addKeyListener(this);
JScrollPane scrollPane = new JScrollPane(panel);
container.add(scrollPane, BorderLayout.CENTER);
@@ -163,13 +191,85 @@ public EdgesFrame(String title, int x, int y) {
panel.setStatusBar(statusBar);
// Let's start with the screen size
- Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
+
int width = Math.min(screen.width, FRAME_WIDTH);
int height = Math.min(screen.height, FRAME_HEIGHT);
setSize(width, height);
setLocation((screen.width - width) / 2, (screen.height - height) / 2);
setResizable(true);
setVisible(true);
+ labels = new HashMap<>();
+ labelScale = 1;
+ addComponentListener(this);
+ /*ActionListener okListener = new ActionListener() {
+
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ System.out.println("2");
+ }
+ };
+ getRootPane().registerKeyboardAction(okListener,
+ KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0),
+ JComponent.WHEN_IN_FOCUSED_WINDOW);*/
+ //KeyStroke k = .getKeyStroke(' ' );
+ //k.getKeyStroke(keyChar, onKeyRelease)
+
+
+ panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(' ' ), "SPACE");
+
+ panel.getActionMap().put("SPACE", new AbstractAction() {
+ public void actionPerformed(ActionEvent e) {
+ //do nothing
+
+ if (panel.getMode()!=modes.handmode)
+ {
+ setMode(modes.handmode);
+ }
+ else
+ setMode(modes.nomode);
+ }
+ });
+
+
+ panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke( KeyEvent.VK_ADD, InputEvent.CTRL_MASK ), "ZOOMIN");
+
+ panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_EQUALS, KeyEvent.CTRL_DOWN_MASK | KeyEvent.SHIFT_DOWN_MASK),"ZOOMIN");
+
+
+ panel.getActionMap().put("ZOOMIN", new AbstractAction() {
+ public void actionPerformed(ActionEvent e) {
+ Point p = panel.getMousePosition();
+ int x1 = (int)p.getX();
+ int y1 = (int)p.getY();
+
+ panel.zoom2Point(x1, y1);
+ panel.setPaintImage();
+ panel.repaint();
+ }
+ });
+
+
+
+ panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_SUBTRACT, InputEvent.CTRL_MASK ), "ZOOMOUT");
+
+ //panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_MINUS, KeyEvent.CTRL_DOWN_MASK | KeyEvent.SHIFT_DOWN_MASK),"ZOOMOUT");
+
+ panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_MINUS, KeyEvent.CTRL_DOWN_MASK),"ZOOMOUT");
+
+
+ panel.getActionMap().put("ZOOMOUT", new AbstractAction() {
+ public void actionPerformed(ActionEvent e) {
+ Point p = panel.getMousePosition();
+ int x1 = (int)p.getX();
+ int y1 = (int)p.getY();
+
+ panel.zoomOutFromPoint(x1, y1);
+ panel.setPaintImage();
+ panel.repaint();
+ }
+ });
+
+
}
private JFileChooser fileChooser;
@@ -210,9 +310,11 @@ private void setMenuBars() {
JMenu fileMenu = new JMenu("File");
fileMenu.setMnemonic('F');
- // LOAD THE EDGES FILE ( SOMETHING.lgl )
- JMenuItem openFile = new JMenuItem("Open .lgl file");
- openFile.setMnemonic('O');
+
+ // load all
+
+ JMenuItem openFile = new JMenuItem("Load all files");
+
openFile.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JFileChooser chooser = getFileChooser("lgl");
@@ -220,11 +322,38 @@ public void actionPerformed(ActionEvent e) {
if (returnVal == JFileChooser.APPROVE_OPTION) {
edgesFile = chooser.getSelectedFile();
loadSHORTFile(edgesFile);
+ File coordsFile = new File(edgesFile.getPath().replace(".lgl", ".coords"));
+ if (coordsFile.isFile())
+ loadCoordsFile(coordsFile);
+ File colorsFile = new File(edgesFile.getPath().replace(".lgl", ".colors"));
+
+ if (colorsFile.isFile())
+ loadEdgeColorFile(colorsFile);
+
+ File labelsFile = new File(edgesFile.getPath().replace(".lgl", ".labels"));
+
+ if (labelsFile.isFile())
+ loadLabelFile(labelsFile);
}
}
});
fileMenu.add(openFile);
+ // LOAD THE EDGES FILE ( SOMETHING.lgl )
+ JMenuItem openAllFile = new JMenuItem("Open .lgl file");
+ openAllFile.setMnemonic('O');
+ openAllFile.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ JFileChooser chooser = getFileChooser("lgl");
+ int returnVal = chooser.showOpenDialog(EdgesFrame.this);
+ if (returnVal == JFileChooser.APPROVE_OPTION) {
+ edgesFile = chooser.getSelectedFile();
+ loadSHORTFile(edgesFile);
+ }
+ }
+ });
+ fileMenu.add(openAllFile);
+
// LOAD THE 2D COORDS
JMenuItem cFile = new JMenuItem("Open 2D Coords file");
cFile.setMnemonic('C');
@@ -335,6 +464,27 @@ public void actionPerformed(ActionEvent e) {
});
fileMenu.add(reload);
+ // load labels
+
+ JMenuItem labelMenu = new JMenuItem("Load labels");
+ labelMenu.setMnemonic('L');
+ labelMenu.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ if (vertexCheck()) {
+ JFileChooser chooser = getFileChooser();
+ int returnVal = chooser.showOpenDialog(EdgesFrame.this);
+ if (returnVal == JFileChooser.APPROVE_OPTION) {
+ loadLabelFile(chooser.getSelectedFile());
+ }
+ }
+ }
+ });
+ fileMenu.add(labelMenu);
+
+
+
+
+
// APPLICATION EXIT
JMenuItem exit = new JMenuItem("Exit");
exit.setMnemonic('x');
@@ -391,13 +541,42 @@ public void actionPerformed(ActionEvent e) {
"Error", JOptionPane.ERROR_MESSAGE);
} else {
zoomStepSize = newZoomStepSize;
- panel.setZoomStepSize(zoomStepSize);
+ formatter.setLabelScale(newZoomStepSize);
+
+
}
}
}
});
edit.add(zoomsize);
+ // change label scale
+
+ JMenuItem labelscalesize = new JMenuItem("Change scale for Labels");
+
+ labelscalesize.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ String newSize = JOptionPane.showInputDialog(EdgesFrame.this,
+ "Enter the new label scale",
+ Double.toString(labelScale));
+ if (newSize != null) {
+ double newLabelScale = Double.parseDouble(newSize);
+ if (newLabelScale <= 0 ) {
+ JOptionPane.showMessageDialog(null, "Illegal Value",
+ "Error", JOptionPane.ERROR_MESSAGE);
+ } else {
+ labelScale = newLabelScale;
+
+ formatter.setLabelScale(labelScale);
+ panel.setPaintImage(); // TODO: move inside panel.xxxx()?
+ panel.repaint();
+ }
+ }
+ }
+ });
+ edit.add(labelscalesize);
+
+
// BUTTON TO REMOVE TRANSIENT EDGES
blockers = new JRadioButton("Remove Transient Edges");
blockers.setMnemonic('R');
@@ -433,6 +612,8 @@ public void actionPerformed(ActionEvent e) {
if (zoomHighlighted.isSelected()) {
panel.prepZoomPoint(true);
statusMessage = "Enabled Zoom Point";
+ setMode(modes.nomode);
+
} else {
panel.prepZoomPoint(false);
statusMessage = "Disabled Zoom Point";
@@ -451,6 +632,7 @@ public void actionPerformed(ActionEvent e) {
if (zoomRegion.isSelected()) {
panel.prepZoomRegion(true);
statusMessage = "Enabled Zoom Region";
+ setMode(modes.nomode);
} else {
panel.prepZoomRegion(false);
statusMessage = "Disabled Zoom Region";
@@ -802,6 +984,23 @@ public void loadVertexColorFile(File f) {
}
}
+ public void loadLabelFile(File f) {
+ System.out.println("Loading Label File " + f.getAbsolutePath());
+ try {
+ edgesio.loadLabelFile(f);
+ // Update the panel with tlabels
+ panel.addLabels(edgesio.getLabels());
+ panel.setPaintImage();
+ panel.repaint();
+ } catch (FileNotFoundException ee) {
+ JOptionPane.showMessageDialog(null, "File Not Found", "Error",
+ JOptionPane.ERROR_MESSAGE);
+ } catch (IOException ee) {
+ JOptionPane.showMessageDialog(null, "IO Error: Check File Format",
+ "Error", JOptionPane.ERROR_MESSAGE);
+ }
+ }
+
public void loadCoordsFile(File f) {
coordsFile = f;
try {
@@ -823,7 +1022,7 @@ public void loadCoordsFile(File f) {
panel.setFont(font);
panel.setMoveStepSize(moveStepSize);
panel.setZoomStepSize(zoomStepSize);
- formatter = new FormatVertex(vertices, edgesio.getStats(),
+ formatter = new FormatVertex(vertices, edgesio.getLabels(),labelScale,0,0,0,0,false,edgesio.getStats(),
windowSizes, threads);
panel.setFormatter(formatter);
panel.fitData();
@@ -854,22 +1053,70 @@ public void loadCoordsFile(File f) {
*/
private JPanel buttonsPanel;
+ private void resetZooms()
+ {
+ panel.prepZoomPoint(false);
+ panel.prepZoomRegion(false);
+ zoomHighlighted.setSelected(false);
+ zoomRegion.setSelected(false);
+ }
+
+ private void inactiveButton(JToggleButton b)
+ {
+ //b.setContentAreaFilled(true);
+ b.setForeground(new JButton().getForeground());
+ b.setSelected(false);
+
+ }
+
+ private void setMode(modes mode)
+ {
+ if (mode==modes.handmode)
+ {
+ panel.handMode();
+ resetZooms();
+ magnifier.setSelected(false);
+ inactiveButton(magnifier);
+ //hand.setContentAreaFilled(false);
+ //hand.setOpaque(true);
+ hand.setForeground(Color.green);
+
+ }
+
+
+
+ if (mode==modes.magnifiermode)
+ {
+ panel.magnifierMode();
+ resetZooms();
+ hand.setSelected(false);
+ inactiveButton(hand);
+ //magnifier.setContentAreaFilled(false);
+ //magnifier.setOpaque(true);
+ magnifier.setForeground(Color.green);
+ }
+
+ if (mode==modes.nomode)
+ {
+ inactiveButton(hand);
+ inactiveButton(magnifier);
+ panel.noMode();
+
+ }
+
+
+ }
+
+
+
private void setButtons() {
buttonsPanel = new JPanel();
((FlowLayout) buttonsPanel.getLayout()).setAlignment(FlowLayout.LEFT);
container.add(buttonsPanel, BorderLayout.NORTH);
- JButton undo = new JButton("Undo");
- undo.addActionListener(new ActionListener() {
- public void actionPerformed(ActionEvent e) {
- panel.undo();
- panel.setPaintImage(); // TODO: move inside panel.xxxx()?
- panel.repaint();
- }
- });
- buttonsPanel.add(undo);
+
- JButton zoomIn = new JButton("In");
+ /*JButton zoomIn = new JButton("In");
zoomIn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
VertexFitter f = new VertexFitter();
@@ -891,9 +1138,61 @@ public void actionPerformed(ActionEvent e) {
panel.repaint();
}
});
- buttonsPanel.add(zoomOut);
+ buttonsPanel.add(zoomOut);*/
+
+
+
+ //hand.setContentAreaFilled(false);
+ //hand.setOpaque(true);
+ //hand.setBackground(Color.black);
+ hand.setFocusable(false);
+
+ //hand.setContentAreaFilled(false);
+ hand.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ System.out.println(hand.getModel().isSelected());
+ if (hand.getModel().isSelected())
+ {
+ setMode(modes.handmode);
+ }
+ else
+ {
+ setMode(modes.nomode);
+
+ //hand.setSelected(false);
+ }
+
+ }
+ });
+ buttonsPanel.add(hand);
+
+
+
+ //magnifier.setContentAreaFilled(false);
+ //magnifier.setOpaque(true);
+ //magnifier.setBackground(Color.black);
+ magnifier.setFocusable(false);
+
+
+ //magnifier.setContentAreaFilled(false);
+ magnifier.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ System.out.println(magnifier.getModel().isSelected());
+ if (magnifier.getModel().isSelected())
+ {
+ setMode(modes.magnifiermode);
+ }
+ else
+ {
+ setMode(modes.nomode);
+ //hand.setSelected(false);
+ }
+
+ }
+ });
+ buttonsPanel.add(magnifier);
- JButton moveup = new JButton("Up");
+ /*JButton moveup = new JButton("Up");
moveup.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel.moveUp();
@@ -931,14 +1230,14 @@ public void actionPerformed(ActionEvent e) {
panel.repaint();
}
});
- buttonsPanel.add(moveright);
+ buttonsPanel.add(moveright);*/
JButton fit = new JButton("Fit");
fit.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// TODO: SESS - twice?
panel.fitData();
- panel.fitData();
+ //panel.fitData();
System.out.println("Fit data still buggy.");
panel.setPaintImage(); // TODO: move inside panel.xxxx()?
panel.repaint();
@@ -996,8 +1295,35 @@ public void actionPerformed(ActionEvent e) {
panel.showVertices(false);
showVertices.setSelected(false);
buttonsPanel.add(showVertices);
+
+ JButton undo = new JButton("Undo");
+ undo.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ panel.undo();
+ panel.setPaintImage(); // TODO: move inside panel.xxxx()?
+ panel.repaint();
+ }
+ });
+ buttonsPanel.add(undo);
}
+ public void keyTyped(KeyEvent e) {
+ // Sys(e, "KEY TYPED: ");
+ }
+
+ /** Handle the key-pressed event from the text field. */
+ public void keyPressed(KeyEvent e) {
+ System.out.println(e.getKeyChar());
+ if (e.getKeyChar()==' ')
+ System.out.println("yes");
+ // displayInfo(e, "KEY PRESSED: ");
+ }
+
+ /** Handle the key-released event from the text field. */
+ public void keyReleased(KeyEvent e) {
+ // displayInfo(e, "KEY RELEASED: ");
+ }
+
class StyleHandler implements ItemListener {
public void itemStateChanged(ItemEvent e) {
int style = 0;
@@ -1037,6 +1363,15 @@ private boolean vertexCheck() {
return true;
}
+ public void componentHidden(ComponentEvent e) {}
+ public void componentMoved(ComponentEvent e) {}
+ public void componentShown(ComponentEvent e) {}
+
+ public void componentResized(ComponentEvent e) {
+ Dimension newSize = e.getComponent().getBounds().getSize();
+ System.out.println("size:"+newSize.width+" "+newSize.height);
+ }
+
}
// ////////////////////////////////////////////////////////////////
@@ -1095,6 +1430,8 @@ public String getExtension(File f) {
return ext;
}
+
+
}
// ////////////////////////////////////////////////////////////////
diff --git a/Java/src/Viewer2D/EdgesPanel.java b/Java/src/Viewer2D/EdgesPanel.java
index 404c3c20..a82bce42 100755
--- a/Java/src/Viewer2D/EdgesPanel.java
+++ b/Java/src/Viewer2D/EdgesPanel.java
@@ -20,20 +20,31 @@
package Viewer2D;
import java.awt.Color;
+import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
+import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
+import java.awt.event.ActionListener;
+import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
+import java.awt.event.MouseWheelListener;
+
+import java.awt.event.MouseWheelEvent;
+
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
+import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;
import java.io.BufferedWriter;
import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.text.MessageFormat;
@@ -42,12 +53,21 @@
import java.util.Map;
import javax.imageio.ImageIO;
+import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import Jama.Matrix;
+import java.awt.BasicStroke;
+import Viewer2D.Label;
+import java.awt.AlphaComposite;
+import java.awt.FontFormatException;
+import java.awt.Point;
+import java.awt.Toolkit;
+import java.awt.Image;
/**
* SESS - 2014.05.13:
@@ -58,12 +78,14 @@
*
*/
public class EdgesPanel extends JPanel implements MouseListener,
- MouseMotionListener {
+ MouseMotionListener, MouseWheelListener {
private static final long serialVersionUID = -765273216020721560L;
private Edge[] edges;
private Vertex[] vertices;
+ private HashMap labels;
+
private int xWindowSize, yWindowSize;
private VertexFitter fitter;
@@ -75,6 +97,8 @@ public class EdgesPanel extends JPanel implements MouseListener,
private Font font;
+ private HashMap fontMap;
+
// These are hashes relating edge/vertex id
// to specific info
private HashMap edgeColorMap;
@@ -103,6 +127,20 @@ public class EdgesPanel extends JPanel implements MouseListener,
// Default font color
private Color fontColor;
+ enum modes
+ {
+ nomode,
+ handmode,
+ magnifiermode
+
+
+ }
+
+ private modes mode;
+ private boolean handtouch = false;
+
+ private Cursor cursorMagnifier;
+
private double x1, y1, x2, y2;
private Matrix mins, maxs;
private Matrix inverted;
@@ -110,6 +148,12 @@ public class EdgesPanel extends JPanel implements MouseListener,
private BufferedImage bufferedImage;
private boolean paintImage;
+ private double defaultScale;
+
+ ModeChanged modeChange;
+
+ private JPopupMenu menu;
+
protected BufferedImage getBufferedImage() {
if (bufferedImage == null) {
bufferedImage = new BufferedImage(xWindowSize, yWindowSize,
@@ -123,6 +167,12 @@ protected BufferedImage getBufferedImage() {
// this.bufferedImage = bufferedImage;
// }
+ public interface ModeChanged {
+ //declare abstract method
+ void onChange(modes m);
+ }
+
+
public boolean isPaintImage() {
return paintImage;
}
@@ -135,7 +185,7 @@ public void setPaintImage() {
paintImage = true;
}
- public EdgesPanel(Edge[] edges, Vertex[] vertices, int xWindowSize,
+ public EdgesPanel(Edge[] edges, Vertex[] vertices, HashMap labels, int xWindowSize,
int yWindowSize) {
super();
@@ -145,9 +195,12 @@ public EdgesPanel(Edge[] edges, Vertex[] vertices, int xWindowSize,
this.setPreferredSize(new Dimension(xWindowSize, yWindowSize));
this.edges = edges;
this.vertices = vertices;
+ this.labels = labels;
addMouseListener(this);
addMouseMotionListener(this);
+ addMouseWheelListener(this);
+
// By default don't draw ids
idsIncluded = false;
@@ -162,6 +215,7 @@ public EdgesPanel(Edge[] edges, Vertex[] vertices, int xWindowSize,
// These are the default colors
edgeColorMap = new HashMap();
vertexColorMap = new HashMap();
+ fontMap = new HashMap();
edgeColor = Color.black;
fontColor = Color.blue;
// Lets start with transparent
@@ -173,6 +227,138 @@ public EdgesPanel(Edge[] edges, Vertex[] vertices, int xWindowSize,
// Matrices need for zooming moving etc
mins = new Matrix(2, 1);
maxs = new Matrix(2, 1);
+ mode = modes.nomode;
+ Image image = null;
+ Toolkit toolkit = Toolkit.getDefaultToolkit();
+ String sep = System.getProperty("file.separator");
+ String workingdir = System.getProperty("user.dir");
+ //System.out.println("Working Directory = " + System.getProperty("user.dir"));
+
+ java.net.URL imgURL = getClass().getResource("icons8-magnifier-67_32x32.png");
+ if(null != imgURL) {
+ System.out.println("Icon URL = " + imgURL.getFile());
+ //Image image = toolkit.getImage(workingdir+sep+"Java/src/Viewer2D"+sep+"icons8-magnifier-67_32x32.png");
+ image = toolkit.getImage(imgURL);
+ }
+ cursorMagnifier = null; // toolkit.createCustomCursor(image , new Point(0,0), "magnifier");
+ setPopup() ;
+ defaultScale = 1;
+ }
+
+
+
+ private void setPopup()
+ {
+
+ menu = new JPopupMenu();
+
+
+
+ JMenuItem fos = new JMenuItem("Fit on Screen");
+ JMenuItem n100 = new JMenuItem("100%");
+ JMenuItem n200 = new JMenuItem("200%");
+ JMenuItem zoomIn = new JMenuItem("Zoom In");
+ JMenuItem zoomOut = new JMenuItem("Zoom Out");
+ menu.add(fos);
+ menu.add(n100);
+ menu.add(n200);
+ menu.addSeparator();
+ menu.add(zoomIn);
+ menu.add(zoomOut);
+
+ fos.addActionListener(new ActionListener(){
+ public void actionPerformed(ActionEvent e) {
+ Dimension r = getBounds().getSize();
+ xWindowSize = r.width;
+ yWindowSize = r.height;
+ //bufferedImage = null;
+ //getBufferedImage();
+ formatter.setWindowSizeX(xWindowSize);
+ formatter.setWindowSizeY(yWindowSize);
+ fitData();
+
+ setPaintImage(); // TODO: move inside panel.xxxx()?
+ repaint();
+ }
+ });
+
+ n100.addActionListener(new ActionListener(){
+ public void actionPerformed(ActionEvent e) {
+ double scale = formatter.getScale();
+ if (scale!=defaultScale)
+ {
+ Point p = getMousePosition();
+ int x1 = (int)p.getX();
+ int y1 = (int)p.getY();
+ double targetScale;
+
+ targetScale = defaultScale/scale;
+
+ zoom2PointBy(x1, y1,targetScale);
+ setPaintImage();
+ repaint();
+
+ }
+
+ }
+ });
+
+ n200.addActionListener(new ActionListener(){
+ public void actionPerformed(ActionEvent e) {
+ double scale = formatter.getScale();
+ if (scale!=defaultScale*2)
+ {
+ Point p = getMousePosition();
+ int x1 = (int)p.getX();
+ int y1 = (int)p.getY();
+ double targetScale;
+
+ targetScale = defaultScale*2/scale;
+
+ zoom2PointBy(x1, y1,targetScale);
+ setPaintImage();
+ repaint();
+
+ }
+
+ }
+ });
+
+ zoomIn.addActionListener(new ActionListener(){
+ public void actionPerformed(ActionEvent e) {
+
+ Point p = getMousePosition();
+ int x1 = (int)p.getX();
+ int y1 = (int)p.getY();
+
+
+ zoom2Point(x1, y1);
+ setPaintImage();
+ repaint();
+
+ }
+ });
+
+ zoomOut.addActionListener(new ActionListener(){
+ public void actionPerformed(ActionEvent e) {
+ Point p = getMousePosition();
+ int x1 = (int)p.getX();
+ int y1 = (int)p.getY();
+
+
+ zoomOutFromPoint(x1, y1);
+ setPaintImage();
+ repaint();
+
+ }
+ });
+
+
+ //setComponentPopupMenu(menu);
+
+
+ //panel.re
+
}
// -------------------------------------------------------
@@ -228,6 +414,7 @@ private void paintImage(Graphics2D g2){
paintColoredEdges(g2);
paintVertices(g2);
paintIds(g2);
+ paintLabels(g2);
}
}
@@ -322,6 +509,7 @@ public void paintColoredVertices(Graphics g) {
}
}
+
public void paintComponent(Graphics g) {
System.out.println("paintComponent() " + g);
super.paintComponent(g);
@@ -342,9 +530,12 @@ public void paintComponent(Graphics g) {
}
public void applyFit(VertexFitter f) {
- for (int ii = 0; ii < vertices.length; ++ii) {
+ /*for (int ii = 0; ii < vertices.length; ++ii) {
f.fitVertex(vertices[ii]);
- }
+
+ }*/
+ formatter.getFitter().setManipulationMatrix(f.getManipulationMatrix());
+ formatter.applyTransformation();
fitter = f;
inverted = fitter.getManipulationMatrix().inverse();
fitter.setManipulationMatrix(inverted);
@@ -352,6 +543,7 @@ public void applyFit(VertexFitter f) {
public void fitData() {
formatter.fitDataToWindow();
+ defaultScale = formatter.getScale();
}
public void setEdges(Edge[] e) {
@@ -376,6 +568,10 @@ public void addVertexColors(HashMap h) {
vertexColorMap.putAll(h);
}
+ public void addLabels(HashMap h) {
+ labels.putAll(h);
+ }
+
public void clearAllEdgeColors() {
edgeColorMap.clear();
}
@@ -671,6 +867,155 @@ private void paintIds(Graphics2D g) {
}
}
+ private class Fontid
+ {
+ String filename;
+ float size;
+
+ Fontid(String f, float s)
+ {
+ filename = f;
+ size = s;
+
+ }
+ public boolean equals(Object o) {
+ return ((Fontid)o).filename == this.filename && ((Fontid)o).size == this.size ;
+ }
+ public int hashCode() {
+ return filename.hashCode()+(int)(size*10);
+ }
+
+ }
+
+ private Font getFont(String ttffile, float size)
+ {
+ Font f = font;
+ Fontid id = new Fontid(ttffile,size);
+ if (fontMap.containsKey(id))
+ {
+ return fontMap.get(id);
+ }
+
+ try {
+ f = Font.createFont(Font.TRUETYPE_FONT, new FileInputStream(ttffile)).deriveFont(size);
+ fontMap.put(id,f);
+ } catch (FontFormatException ffe) {
+ System.out.println("Tried to load a bad font...");
+ ffe.printStackTrace();
+ }
+ catch (FileNotFoundException e) {
+ System.out.println("could not open file"+ ttffile);
+ e.printStackTrace();
+ }
+ catch (IOException ioe) {
+ System.out.println("I have no idea what went wrong");
+ ioe.printStackTrace();
+ }
+
+ return f;
+ }
+
+ private void drawStringWithBackground(Graphics2D g,String text, int x, int y, Color bgcolor, Color textcolor)
+ {
+
+ //g.setFont(new Font())
+ //Font.createFont(Font.TRUETYPE_FONT, new FileInputStream("font.ttf"));
+ FontMetrics fm = g.getFontMetrics();
+ Rectangle2D rect = fm.getStringBounds(text, g);
+
+ if (bgcolor!=null)
+ {
+ g.setColor(bgcolor);
+ g.fillRect(x,
+ y - fm.getAscent(),
+ (int) rect.getWidth(),
+ (int) rect.getHeight());
+ }
+
+ g.setColor(textcolor);
+ g.drawString(text, x, y);
+
+
+ }
+
+ public void paintLabels(Graphics2D g)
+ {
+ if (vertices == null) {
+ return;
+ }
+ if (labels == null) {
+ return;
+ }
+ labels.forEach((k,v) -> { //System.out.println("Key = "
+ //+ k + ", Value = " + v);
+ //System.out.println("key: " + name);
+ //Label l = labels.get(name);
+ Label l = (Label)v;
+ Vertex vertex = (Vertex) k;
+ if (l.linesize!=0 && l.linecolor != null)
+ {
+ g.setColor(l.linecolor);
+ g.setStroke(new BasicStroke(l.linesize*1.0f));
+ }
+ double rad = (90-l.lineangle)/360*2*Math.PI;
+ double xdiff = l.linelength * Math.cos(rad);
+ double ydiff = -l.linelength * Math.sin(rad);
+ double xstart = vertex.location().get(0, 0);
+ double ystart = vertex.location().get(1, 0);
+ double xend = xstart+xdiff;
+ double yend = ystart+ydiff;
+ if (l.linesize!=0 && l.linecolor != null)
+ g.draw(new Line2D.Double(xstart,ystart,xend, yend));
+
+ if (l.shape.equals("circle"))
+ {
+ double radius = l.shapesize;
+ //g.setColor(l.shapefillcolor);
+ //g.fillOval(x, y, width, height);
+ //Shape theCircle = new Ellipse2D.Double(xstart - radius, ystart - radius, 2.0 * radius, 2.0 * radius);
+
+ //BasicStroke dashed =new BasicStroke(3.0f,BasicStroke.CAP_BUTT,BasicStroke.JOIN_MITER,10.0f);
+ BasicStroke stroke1 =new BasicStroke(l.shapeborderwidth);
+ Ellipse2D.Double circle = new Ellipse2D.Double(xstart - radius, ystart - radius, 2.0 * radius, 2.0 * radius);
+ Ellipse2D.Double circleBorder = new Ellipse2D.Double(xstart - radius, ystart - radius, 2.0 * radius, 2.0 * radius);
+ g.setColor(l.shapefillcolor);
+ //g2.setRenderingHints(hints);
+ g.fill(circle);
+ //Composite oldComposite=g.getComposite();
+ //g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0));
+ g.setColor(l.shapebordercolor);
+ g.setStroke(stroke1);
+ g.draw(circleBorder);
+ //g2.setComposite(oldComposite);
+ }
+ if (!l.toptext.isEmpty())
+ {
+ g.setFont(getFont(l.toptextttf,(float)l.toptextsize));
+ drawStringWithBackground(g,l.toptext, (int)xend, (int)yend, l.topbgfillcolor, l.toptextcolor);
+ }
+ if (!l.bottomtext.isEmpty())
+ {
+ double xend2 = xend;
+ double yend2 = yend;
+ if (!l.toptext.isEmpty())
+ {
+ FontMetrics fm = g.getFontMetrics();
+ Rectangle2D rect = fm.getStringBounds(l.bottomtext, g);
+ yend2+=rect.getHeight();
+ }
+ else
+ {
+
+ }
+ g.setFont(getFont(l.bottomtextttf,(float)l.bottomtextsize));
+ drawStringWithBackground(g,l.bottomtext, (int)xend, (int)yend2, l.bottombgfillcolor, l.bottomtextcolor);
+ }
+
+
+ });
+
+ }
+
public void paintVertices(Graphics g) {
if (vertices == null) {
return;
@@ -898,6 +1243,7 @@ public void runZoomRegion() {
}
}
+
public void zoomIn(VertexFitter f) {
if (edges == null) {
return;
@@ -910,11 +1256,36 @@ public void zoomIn(VertexFitter f) {
setPaintImage();
}
+ public void zoomIn2(VertexFitter f) {
+ zoom(f,1/zoomStepSize);
+ }
+
+ public void zoom(VertexFitter f, double scale)
+ {
+ if (edges == null) {
+ return;
+ }
+ Transformer trans = new Transformer();
+ trans.scale(scale);
+ f.addManipulation(trans);
+ setPaintImage();
+
+ }
+
+ public void zoomOut2(VertexFitter f) {
+ zoom(f,zoomStepSize);
+ }
+
public void zoomOut(VertexFitter f) {
if (edges == null) {
return;
}
+ /*mins.set(0, 0, -zoomStepSize * xWindowSize);
+ mins.set(1, 0, -zoomStepSize * yWindowSize);
+ maxs.set(0, 0, xWindowSize + zoomStepSize * xWindowSize);
+ maxs.set(1, 0, yWindowSize + zoomStepSize * yWindowSize);*/
+
mins.set(0, 0, -zoomStepSize * xWindowSize);
mins.set(1, 0, -zoomStepSize * yWindowSize);
maxs.set(0, 0, xWindowSize + zoomStepSize * xWindowSize);
@@ -923,23 +1294,82 @@ public void zoomOut(VertexFitter f) {
zoomPrep(f);
}
+ public void handMode()
+ {
+ mode = modes.handmode;
+ setCursor(new Cursor(Cursor.HAND_CURSOR));
+ setComponentPopupMenu(null);
+ //menu.setVisible(false);
+
+ }
+
+ modes getMode()
+ {
+ return mode;
+
+ }
+
+ public void magnifierMode()
+ {
+ mode = modes.magnifiermode;
+ setCursor(cursorMagnifier);
+ setComponentPopupMenu(menu);
+
+
+ }
+
+ public void noMode()
+ {
+ mode = modes.nomode;
+ setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
+ setComponentPopupMenu(null);
+ //menu.setVisible(false);
+ }
+
public void zoom2Point(double x, double y) {
if (edges == null) {
return;
}
VertexFitter f = new VertexFitter();
+ move2Point(-x, -y, f);
+ zoomIn2(f);
move2Point(x, y, f);
- zoomIn(f);
+
+
+ //move2Point(-x, -y, f);
+ //move2Point(-2*x/zoomStepSize, -2*y/zoomStepSize, f);
applyFit(f);
}
+ public void zoom2PointBy(double x, double y, double scale) {
+ if (edges == null) {
+ return;
+ }
+ VertexFitter f = new VertexFitter();
+ move2Point(-x, -y, f);
+ zoom(f,scale);
+ move2Point(x, y, f);
+
+
+ //move2Point(-x, -y, f);
+ //move2Point(-2*x/zoomStepSize, -2*y/zoomStepSize, f);
+ applyFit(f);
+ }
+
+
+
public void zoomOutFromPoint(double x, double y) {
if (edges == null) {
return;
}
VertexFitter f = new VertexFitter();
+ //move2Point(x, y, f);
+ //zoomOut(f);
+ move2Point(-x, -y, f);
+ zoomOut2(f);
move2Point(x, y, f);
- zoomOut(f);
+
+
applyFit(f);
}
@@ -949,7 +1379,7 @@ private void zoomPrep(VertexFitter f) {
double spany = maxs.get(1, 0) - mins.get(1, 0);
// Scale to fit new range
scales[0] = xWindowSize / spanx;
- scales[1] = yWindowSize / spany;
+ scales[1] = xWindowSize / spanx;//yWindowSize / spany;
Transformer trans = new Transformer();
trans.scale(scales);
f.addManipulation(trans);
@@ -1045,8 +1475,8 @@ private void move2Point(double x, double y, VertexFitter f) {
return;
}
double[] moves = new double[2];
- moves[0] = -x + xWindowSize * .5;
- moves[1] = -y + yWindowSize * .5;
+ moves[0] = -x;// + xWindowSize * .5;
+ moves[1] = -y; //+ yWindowSize * .5;
Transformer trans = new Transformer();
trans.move(moves);
f.addManipulation(trans);
@@ -1082,6 +1512,14 @@ private void setRenderingHints(Graphics2D g2) {
// -----------------------------------------------------
public void mousePressed(MouseEvent e) {
+ if (mode == modes.handmode)
+ {
+ x1 = e.getX();
+ y1 = e.getY();
+ handtouch = true;
+ System.out.println("click");
+ }
+ else
if (zoomRegion || idRegion) {
x1 = e.getX();
y1 = e.getY();
@@ -1091,6 +1529,10 @@ public void mousePressed(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
+ if (mode == modes.handmode && handtouch)
+ {
+ handtouch = false;
+ }
if (zoomRegion || idRegion) {
x2 = e.getX();
y2 = e.getY();
@@ -1113,6 +1555,44 @@ public void mouseReleased(MouseEvent e) {
}
public void mouseDragged(MouseEvent e) {
+ if (mode == modes.handmode && handtouch)
+ {
+ if (edges == null) {
+ return;
+ }
+ System.out.println("updating" + e.getX());
+ double x2 = e.getX();
+ double y2 = e.getY();
+
+
+ double ymove = y2-y1;
+
+ double xmove = x2-x1;
+
+ mins.set(0, 0, xmove);
+ mins.set(1, 0, ymove);
+ maxs.set(0, 0, xmove+ xWindowSize);
+ maxs.set(1, 0, ymove + yWindowSize);
+
+ VertexFitter f = new VertexFitter();
+ movePrep(f);
+ applyFit(f);
+ setPaintImage(); // TODO: move inside panel.xxxx()?
+ repaint();
+
+
+
+
+ /*double move = moveStepSize * yWindowSize;
+
+ mins.set(0, 0, move);
+ mins.set(1, 0, 0);
+ maxs.set(0, 0, xWindowSize + move);
+ maxs.set(1, 0, yWindowSize);*/
+ x1 = x2;
+ y1 = y2;
+
+ }
if (zoomRegion || idRegion) {
statusBar.setText("Highlighting region from (" + x1 + "," + y1
+ ") to (" + e.getX() + "," + e.getY() + ")");
@@ -1120,6 +1600,18 @@ public void mouseDragged(MouseEvent e) {
}
public void mouseClicked(MouseEvent e) {
+
+ if (mode==modes.magnifiermode)
+ {
+ x1 = e.getX();
+ y1 = e.getY();
+
+ zoom2Point(x1, y1);
+ setPaintImage();
+ repaint();
+
+ }
+
if (zoomPoint) {
x1 = e.getX();
y1 = e.getY();
@@ -1128,11 +1620,13 @@ public void mouseClicked(MouseEvent e) {
statusBar.setText(statusMessage + ": Zooming to (" + x1 + ","
+ y1 + ")");
zoom2Point(x1, y1);
+ setPaintImage();
repaint();
} else if (SwingUtilities.isRightMouseButton(e)) {
statusBar.setText(statusMessage + ": Zooming out from (" + x1
+ "," + y1 + ")");
zoomOutFromPoint(x1, y1);
+ setPaintImage();
repaint();
} else {
statusBar
@@ -1142,6 +1636,10 @@ public void mouseClicked(MouseEvent e) {
}
public void mouseMoved(MouseEvent e) {
+
+ //System.out.println(e.getX()+" "+e.getY());
+
+
}
public void mouseEntered(MouseEvent e) {
@@ -1150,4 +1648,50 @@ public void mouseEntered(MouseEvent e) {
public void mouseExited(MouseEvent e) {
}
+ public void mouseWheelMoved(MouseWheelEvent e) {
+
+ if (mode==modes.magnifiermode)
+ {
+ int notches = e.getWheelRotation();
+ x1 = e.getX();
+ y1 = e.getY();
+ if (notches < 0)
+ {
+
+ zoom2Point(x1, y1);
+ setPaintImage();
+ repaint();
+ /*VertexFitter f = new VertexFitter();
+ zoomIn(f);
+ applyFit(f);
+ setPaintImage(); // TODO: move inside panel.xxxx()?
+ repaint();*/
+ }
+ else
+ {
+ zoomOutFromPoint(x1, y1);
+ setPaintImage();
+ repaint();
+ /*VertexFitter f = new VertexFitter();
+ zoomOut(f);
+ applyFit(f);
+ setPaintImage(); // TODO: move inside panel.xxxx()?
+ repaint();*/
+
+ }
+
+ }
+ String message;
+ /*int notches = e.getWheelRotation();
+ if (notches < 0) {
+ message = "Mouse wheel moved UP "
+ + -notches + " notch(es)\n";
+ } else {
+ message = "Mouse wheel moved DOWN "
+ + notches + " notch(es)\n";
+ }
+ System.out.println(message);*/
+
+ }
+
}
diff --git a/Java/src/Viewer2D/FileInputHandler.java b/Java/src/Viewer2D/FileInputHandler.java
index 88ac8766..55eaa351 100755
--- a/Java/src/Viewer2D/FileInputHandler.java
+++ b/Java/src/Viewer2D/FileInputHandler.java
@@ -23,6 +23,7 @@
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
+import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.Vector;
@@ -56,8 +57,8 @@ public FileInputHandler(String filename) throws FileNotFoundException {
}
// MUTATORS
- public void setDelimeters(String delimiters) {
- this.delimeters = delimeters;
+ public void setDelimeters(String delimiters_) {
+ this.delimeters = delimiters_;
}
// ACCESSORS
@@ -82,12 +83,24 @@ public boolean readNextLine() throws IOException {
return true;
}
- public double getTokenAsDouble(int i) {
- return Double.parseDouble((String) tokens.elementAt(i));
+ public Double getTokenAsDouble(int i) {
+ try
+ {
+ return Double.parseDouble((String) tokens.elementAt(i));
+ }
+ catch (NumberFormatException nfe) {
+ return null;
+ }
}
- public int getTokenAsInt(int i) {
+ public Integer getTokenAsInt(int i) {
+ try
+ {
return Integer.parseInt((String) tokens.elementAt(i));
+ }
+ catch (NumberFormatException nfe) {
+ return null;
+ }
}
public void print() {
@@ -100,10 +113,32 @@ private void performSplit() {
if (text == null) {
return;
}
- tokenizer = new StringTokenizer(text, delimeters);
+ tokenizer = new StringTokenizer(text, delimeters,true);
+
+ //String[] stringArr ;
+ //tokens = new Vector( Arrays.asList(text.split(delimeters)));
+ boolean lastissep = false;
while (tokenizer.hasMoreTokens()) {
- tokens.addElement(tokenizer.nextElement());
+ Object o = tokenizer.nextElement();
+ if (((String)(o)).equals(delimeters))
+ {
+ tokens.addElement("");
+ lastissep = true;
+ }
+ else
+ {
+ tokens.addElement(o);
+ lastissep = false;
+ if (tokenizer.hasMoreTokens())
+ {
+ tokenizer.nextElement();
+ lastissep = true;
+ }
+ }
+
}
+ if (lastissep)
+ tokens.addElement("");
}
}
diff --git a/Java/src/Viewer2D/FormatVertex.java b/Java/src/Viewer2D/FormatVertex.java
index 168fe446..ea699400 100755
--- a/Java/src/Viewer2D/FormatVertex.java
+++ b/Java/src/Viewer2D/FormatVertex.java
@@ -19,6 +19,10 @@
package Viewer2D;
+import java.util.HashMap;
+
+import Jama.Matrix;
+
public class FormatVertex {
private Vertex[] vertices;
private VertexStats stats;
@@ -26,15 +30,35 @@ public class FormatVertex {
private int threadCount;
private static int DIMENSION = Vertex.DIMENSION;
private VertexFitter fitter;
+ private HashMap labels;
+ private double scaleBy;
+ private double scaleCorrectionLabels;
+ private double scaleCorrectionLabelsOriginal;
+ private boolean scaleLabelUsed;
+ private double minX, maxX;
+ private double minY, maxY;
+ boolean aligncenter;
// CONSTRUCTORS
- public FormatVertex(Vertex[] e, VertexStats stats, int[] wSizes,
+ public FormatVertex(Vertex[] e, HashMap labels,double scaleLabels,double minX, double minY,double maxX,double maxY,
+ boolean aligncenter,
+ VertexStats stats, int[] wSizes,
int threads2use) {
vertices = e;
this.stats = stats;
windowSizes = wSizes;
threadCount = threads2use;
+ this.labels = labels;
fitter = new VertexFitter();
+ this.scaleCorrectionLabels = scaleLabels;
+ this.minX = minX;
+ this.maxX = maxX;
+ this.minY = minY;
+ this.maxY = maxY;
+ this.aligncenter = aligncenter;
+ scaleBy = 1;
+ scaleLabelUsed = false;
+
}
// MUTATORS
@@ -44,10 +68,10 @@ public void fitDataToWindow() {
// Here the appropriate translation/scaling matrices
// must be generated and applied to the originalVertices.
// Stretch the vertices to fit the window
- scalingIssues();
-
+ double scale = scalingIssues();
+
// Recenter the vertices based on the avg of max and min values
- translationIssues();
+ translationIssues(scale);
applyTransformation();
}
@@ -72,6 +96,16 @@ public void setWindowSizeY(int y) {
windowSizes[1] = y;
}
+ public void setLabelScale(double scale)
+ {
+
+ scaleCorrectionLabels = scale/(scaleLabelUsed? scaleCorrectionLabelsOriginal: scaleCorrectionLabels);
+ scaleLabelUsed = false;
+ scaleLabels(1);
+
+ }
+
+
public void threads(int t) {
threadCount = t;
}
@@ -92,6 +126,11 @@ public int[] windowSizes() {
public int threads() {
return threadCount;
}
+
+ public double getScale()
+ {
+ return scaleBy;
+ }
public VertexFitter getFitter() {
return fitter;
@@ -106,40 +145,118 @@ public void print() {
// PRIVATE METHOD CALLS
// /////////////////////////////////////////////////////////////////////
- private void translationIssues() {
+ private void translationIssues(double scale) {
double[] offsets = new double[DIMENSION];
- for (int d = 0; d < DIMENSION; ++d) {
- offsets[d] -= stats.min(d);
+
+ if (aligncenter) {
+ for (int d = 0; d < DIMENSION; ++d) {
+ offsets[d] = ((double) windowSizes[d]) / (2 * scale) - stats.avg(d);
+ }
+ }
+ else {
+ for (int d = 0; d < DIMENSION; ++d) {
+ offsets[d] -= stats.min(d);
+ }
}
+
Transformer transformer = new Transformer();
transformer.move(offsets);
// Add this job to the list
fitter.addManipulation(transformer);
}
- private void scalingIssues() {
- double scale = windowSizes[0] / stats.span(0);
- for (int d = 1; d < DIMENSION; ++d) {
- double newScale = windowSizes[d] / stats.span(d);
- if (newScale < scale) {
- scale = newScale;
- }
- }
+ private double scalingIssues() {
+ double scale;
+
+ if (minX!=0 && maxX!=0)
+ scale = windowSizes[0] / ( maxX-minX);
+ else
+ scale = windowSizes[0] / stats.span(0);
+
+
+ for (int d = 1; d < DIMENSION; ++d) {
+ double newScale = windowSizes[d] / stats.span(d);
+ if (newScale < scale) {
+ scale = newScale;
+ }
+ }
+
Transformer transformer = new Transformer();
transformer.scale(.99 * scale);
+ // scaleBy = .99 * scale;
fitter.addManipulation(transformer);
+
+ return .99 * scale;
+ }
+
+ private double calculateScale()
+ {
+ Matrix m = fitter.getManipulationMatrix();
+ double sum = 0;
+ for (int i = 0; i < Vertex.DIMENSION;i++)
+ sum += m.get(0, i)*m.get(0, i);
+
+ double scale = Math.sqrt(sum);
+
+ return scale;
+
}
- private void applyTransformation() {
+ private void scaleLabels(double currentScale)
+ {
+ labels.forEach((k,v) -> {
+ Label l = (Label)v;
+ Vertex vertex = (Vertex) k;
+ l.linelength =(l.linelength * currentScale * scaleCorrectionLabels);
+ //l.linesize =(int) (l.linesize * scaleBy * scaleCorrectionLabels);
+ l.bottomtextsize = (l.bottomtextsize * currentScale * scaleCorrectionLabels);
+ l.toptextsize = (l.toptextsize * currentScale * scaleCorrectionLabels);
+ l.shapesize = (l.shapesize * currentScale * scaleCorrectionLabels);
+
+ });
+ if (!scaleLabelUsed)
+ {
+ scaleCorrectionLabelsOriginal = scaleCorrectionLabels;
+
+ }
+ scaleLabelUsed = true;
+ scaleCorrectionLabels = 1;
+
+
+ }
+
+ public void applyTransformation() {
+ double currentScale = calculateScale();
+ scaleBy = scaleBy * currentScale;
// Now to do the work to each vertex
+ long start = System.nanoTime();
+ ManipVertexArray manipa[] = new ManipVertexArray[threadCount];
+ // VertexStats statsa[] = new VertexStats[threadCount];
+
for (int t = 0; t < threadCount; ++t) {
- ManipVertexArray manip = new ManipVertexArray(vertices);
+ ManipVertexArray manip = new ManipVertexArray(vertices,"vertexrecalc"+t);
+ manipa[t] = manip;
+ // statsa[t] = new VertexStats();
manip.setFitter(fitter);
manip.setStride(threadCount);
manip.setOffset(t);
manip.setVertexStats(stats); // Fix this if threading (race cond.)
- manip.run();
+ manip.start();
+ }
+ for (int t = 0; t < threadCount;t++)
+ {
+ try {
+ manipa[t].getThread().join();
+ } catch (InterruptedException e) {
+
+ e.printStackTrace();
+ }
+
}
+ long end = System.nanoTime();
+ System.out.println("Time to recalculate vertices "+(end-start)/1000000000.0+"s");
+ scaleLabels(currentScale);
+
}
}
diff --git a/Java/src/Viewer2D/Label.java b/Java/src/Viewer2D/Label.java
new file mode 100644
index 00000000..96834638
--- /dev/null
+++ b/Java/src/Viewer2D/Label.java
@@ -0,0 +1,91 @@
+package Viewer2D;
+
+import Jama.Matrix;
+
+import java.awt.Color;
+
+public class Label {
+
+
+ //private Vertex id;
+ public double shapesize ;
+ public String shape ;
+ public int shapeborderwidth ;
+ public Color shapebordercolor;
+
+ public Color shapefillcolor ;
+
+ public double shapefillopacity ;
+ public int linesize ;
+ public double linelength ;
+ public double lineangle;
+ public Color linecolor;
+
+ public String toptextttf;
+ public double toptextsize ;
+ public Color toptextcolor ;
+ public Color topbgfillcolor ;
+
+ public String bottomtextttf ;
+ public double bottomtextsize ;
+ public Color bottomtextcolor ;
+ public Color bottombgfillcolor ;
+
+ public String toptext;
+ public String bottomtext;
+ Label(
+ String shape_ ,
+ int shapesize_ ,
+ int shapeborderwidth_ ,
+ Color shapebordercolor_,
+
+ Color shapefillcolor_ ,
+
+ double shapefillopacity_ ,
+ int linesize_ ,
+ int linelength_ ,
+ double lineangle_,
+ Color linecolor_,
+
+ String toptextttf_,
+ int toptextsize_ ,
+ Color toptextcolor_ ,
+ Color topbgfillcolor_ ,
+
+ String bottomtextttf_ ,
+ int bottomtextsize_ ,
+ Color bottomtextcolor_ ,
+ Color bottombgfillcolor_ ,
+
+ String toptext_,
+ String bottomtext_)
+ {
+ //id=id_;
+ shape = shape_;
+ shapesize = shapesize_;
+ shapeborderwidth = shapeborderwidth_;
+ shapebordercolor = shapebordercolor_;
+ shapefillcolor = shapefillcolor_;
+ shapefillopacity = shapefillopacity_;
+ linesize = linesize_;
+ linelength = linelength_;
+ lineangle = lineangle_;
+ linecolor = linecolor_;
+ toptextttf = toptextttf_;
+ toptextsize = toptextsize_;
+ toptextcolor = toptextcolor_;
+ topbgfillcolor = topbgfillcolor_;
+ bottomtextttf = bottomtextttf_;
+ bottomtextsize = bottomtextsize_;
+ bottomtextcolor = bottomtextcolor_;
+ bottombgfillcolor = bottombgfillcolor_;
+ toptext = toptext_;
+ bottomtext = bottomtext_;
+
+ }
+
+
+
+
+
+}
\ No newline at end of file
diff --git a/Java/src/Viewer2D/ManipVertexArray.java b/Java/src/Viewer2D/ManipVertexArray.java
index a057d1d5..af270457 100755
--- a/Java/src/Viewer2D/ManipVertexArray.java
+++ b/Java/src/Viewer2D/ManipVertexArray.java
@@ -22,34 +22,52 @@
import Jama.*;
import Jama.Matrix.*;
-public class ManipVertexArray {
+public class ManipVertexArray implements Runnable{
private int off; // Array offset to start
private int stride; // Steps to skip each time
private VertexFitter fitter;
private Vertex[] vertices;
private VertexStats stats;
+ private Thread t;
+ private String threadName;
+ static final Object object = new Object();
// CONSTRUCTORS
- public ManipVertexArray( Vertex[] verticesO )
+ public ManipVertexArray( Vertex[] verticesO ,String threadName)
{
// This is setup for 1 thread by default
off = 0;
stride = 1;
vertices = verticesO;
+ this.threadName = threadName;
+ }
+ Thread getThread()
+ {
+ return t;
}
-
public void run()
{
- stats.clear();
+
for ( int e = off; e < vertices.length; e += stride ) {
fitter.fitVertex( vertices[e] );
- stats.addStatsOfVertex( vertices[e] );
+ // synchronized(object)
+ {
+ stats.addStatsOfVertex( vertices[e] );
+ }
}
}
+ public void start () {
+ System.out.println("Starting " + threadName );
+ if (t == null) {
+ t = new Thread (this, threadName);
+ t.start ();
+ }
+ }
+
// ACCESSORS
public void print() {
diff --git a/Java/src/Viewer2D/VertexFitter.java b/Java/src/Viewer2D/VertexFitter.java
index 34463ca0..2ab2d58e 100755
--- a/Java/src/Viewer2D/VertexFitter.java
+++ b/Java/src/Viewer2D/VertexFitter.java
@@ -55,6 +55,8 @@ public void fitVertex( Vertex original )
original.location( manipulation.times( original.location() ) );
}
+
+
// This is to add a manipulation to the 'to do' list.
// This permits composite manipulations
public void addManipulation( Transformer manip )
diff --git a/Java/src/Viewer2D/VertexStats.java b/Java/src/Viewer2D/VertexStats.java
index d37cac2d..72e688f7 100755
--- a/Java/src/Viewer2D/VertexStats.java
+++ b/Java/src/Viewer2D/VertexStats.java
@@ -129,14 +129,31 @@ public Matrix maxs() {
public void print() {
System.out.println("\tS T A T S");
- System.out.println("Mins: ");
- mins.print(4, 2);
- System.out.println("Maxs: ");
- maxs.print(4, 2);
+ System.out.print("Mins: ");
+ String [] names = {"x:","y:","z:"};
+ for (int i = 0; i < DIMENSION;i++)
+ {
+ System.out.print(names[i]+" "+mins.get(i,0));
+
+ if (i!=DIMENSION)
+ System.out.print(" ");
+ }
+ System.out.println();
+ //mins.print(4, 2);
+ System.out.print("Maxs: ");
+ //maxs.print(4, 2);
+ for (int i = 0; i < DIMENSION;i++)
+ {
+ System.out.print(names[i]+" "+maxs.get(i,0));
+
+ if (i!=DIMENSION)
+ System.out.print(" ");
+ }
+ System.out.println();
System.out.println("Totals: ");
- totals.print(4, 2);
+ //totals.print(4, 2);
for (int ii = 0; ii < DIMENSION; ++ii) {
- System.out.println("Avg" + ii + ": " + avg(ii));
+ System.out.println("Avg " + names[ii] + " " + avg(ii));
}
System.out.println("Vertices Counted: " + vertexCtr);
}
diff --git a/Java/src/Viewer2D/Viewer2D.java b/Java/src/Viewer2D/Viewer2D.java
index 01ebeec9..0e7b6712 100755
--- a/Java/src/Viewer2D/Viewer2D.java
+++ b/Java/src/Viewer2D/Viewer2D.java
@@ -21,9 +21,15 @@
import java.io.File;
+import javax.swing.InputMap;
+import javax.swing.KeyStroke;
import javax.swing.UIManager;
import javax.swing.UIManager.LookAndFeelInfo;
+import ImageMaker.GenerateImages;
+
+import java.awt.Insets;
+
/**
* SESS - 2014.05.11:
*
@@ -49,6 +55,9 @@ public static void main(String[] args) {
} catch (Exception e) {
e.printStackTrace();
}
+ String OS = System.getProperty("os.name").toLowerCase();
+ //if (OS.contains("win"))
+ // UIManager.put("MenuItem.margin", new Insets(2, -15, 2, 2));
} else {
for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
if (laf.equals(info.getName())) {
@@ -62,22 +71,31 @@ public static void main(String[] args) {
}
}
+ InputMap im = (InputMap)UIManager.get("Button.focusInputMap");
+ im.put(KeyStroke.getKeyStroke("pressed SPACE"), "none");
+ im.put(KeyStroke.getKeyStroke("released SPACE"), "none");
+
// create a new frame object
EdgesFrame frame = new EdgesFrame("lglview", IMAGE_SIZE, IMAGE_SIZE);
+ GenerateImages.ParseArguments pa = new GenerateImages.ParseArguments(true);
+ pa.parse(args);
+
// Deal with possible command line args
// The first entry is a possible edges file (.ls) and the next
// file is a possible coord file
- if (args.length > 0) {
- System.out.println("Loading edges file " + args[0]);
- frame.loadSHORTFile(new File(args[0]));
- if (args.length > 1) {
- System.out.println("Loading coords file " + args[1]);
+ if (args.length > 0)
+ {
+ System.out.println("Loading edges file " + pa.edgeFile);
+ frame.loadSHORTFile(new File(pa.edgeFile));
+ //if (args.length > 1)
+ {
+ System.out.println("Loading coords file " + pa.coordFiles.get(0));
frame.loadCoordsFile(new File(args[1]));
}
- if (args.length > 2) {
- System.out.println("Loading color file " + args[2]);
- File colorfile = new File(args[2]);
+ if (!pa.edgeColorFile.isEmpty()) {
+ System.out.println("Loading color file " + pa.edgeColorFile);
+ File colorfile = new File(pa.edgeColorFile);
frame.loadEdgeColorFile(colorfile);
}
}
diff --git a/Java/src/Viewer2D/ViewerIO.java b/Java/src/Viewer2D/ViewerIO.java
index 8cbf7132..31ea9276 100755
--- a/Java/src/Viewer2D/ViewerIO.java
+++ b/Java/src/Viewer2D/ViewerIO.java
@@ -63,11 +63,59 @@ public class ViewerIO {
private HashMap vertexColorMap;
private Vector edgesV;
private Vector verticesV;
+ private HashMap labelMap;
+ private double scalingLabel;
+ private double customMinX;
+ private double customMaxX;
+ private double customMinY;
+ private double customMaxY;
public ViewerIO(File filename) throws FileNotFoundException, IOException {
file = filename;
edgeColorMap = new HashMap();
vertexColorMap = new HashMap();
+ labelMap = new HashMap();
+ scalingLabel = 1;
+ customMinX = 0;
+ customMaxX = 0;
+ customMinY = 0;
+ customMaxY = 0;
+
+ }
+
+ public void setLabelScale(double scale)
+ {
+ this.scalingLabel = scale;
+ }
+
+ public void setMinMaxXY(double minx, double miny,double maxx, double maxy)
+ {
+ customMinX = minx;
+ customMaxX = maxx;
+ customMinY = miny;
+ customMaxY = maxy;
+
+ }
+
+ public double getMinX() {
+ return customMinX;
+ }
+
+ public double getMaxX() {
+ return customMaxX;
+ }
+
+ public double getMinY() {
+ return customMinY;
+ }
+
+ public double getMaxY() {
+ return customMaxY;
+ }
+
+
+ public double getLabelScale() {
+ return this.scalingLabel;
}
// TODO: SESS - should move to "utils" class?
@@ -240,6 +288,128 @@ public void loadVertexColorFile(File f) throws IOException,
}
}
+ public void clearLabels()
+ {
+ labelMap.clear();
+ }
+
+ public void loadLabelFile(File f) throws IOException,FileNotFoundException {
+ if (edges == null || vertices == null) {
+ return;
+ }
+ labelMap.clear();
+ fileio = new FileInputHandler(f.getAbsolutePath());
+ fileio.setDelimeters(",");
+ while (fileio.readNextLine()) {
+ int s = fileio.getTokenCount();
+ if (s != 21) {
+ throw new IOException("number of fields are not correct in the file");
+ }
+
+ int index = 0;
+ String id = fileio.getToken(index++);
+ String shape = fileio.getToken(index++);
+ Integer shapesize = fileio.getTokenAsInt(index++);
+ Integer shapeboarderwidth = fileio.getTokenAsInt(index++);
+
+
+
+ Color shapebordercolor = readColorRGBHex(index++);
+
+ Color shapefillcolor = readColorRGBHexAlpha(index++);
+ index++;
+ double shapefillopacity = 0;//fileio.getTokenAsDouble(index++);
+ if (shapesize == null || shapeboarderwidth == null || shapebordercolor == null || shapefillcolor == null)
+ {
+ shapesize = 0;
+ shapeboarderwidth = 0;
+ shape = "";
+ }
+
+
+ Integer linesize = fileio.getTokenAsInt(index++);
+ Integer linelength = fileio.getTokenAsInt(index++);
+ Double lineangle = fileio.getTokenAsDouble(index++);
+ Color linecolor = readColorRGBHex(index++);
+
+
+
+
+ String toptextttf = fileio.getToken(index++);
+ Integer toptextsize = fileio.getTokenAsInt(index++);
+ Color toptextcolor = readColorRGBHex(index++);
+ Color topbgfillcolor =readColorRGBHex(index++);
+
+ String bottomtextttf = fileio.getToken(index++);
+ Integer bottomtextsize = fileio.getTokenAsInt(index++);
+ Color bottomtextcolor = readColorRGBHex(index++);
+ Color bottombgfillcolor =readColorRGBHex(index++);
+
+ String toptext = fileio.getToken(index++);
+ String bottomtext = fileio.getToken(index++);
+
+
+ if (toptextttf.isEmpty() || toptextsize== null || toptextcolor == null)
+ {
+ toptext = "";
+ toptextsize = 0;
+ }
+
+ if (bottomtextttf.isEmpty() || bottomtextsize== null || bottomtextcolor == null)
+ {
+ bottomtext = "";
+ bottomtextsize = 0;
+ }
+
+
+
+ if (linesize == null)
+ {
+ linecolor = null;
+ linesize = 0;
+ }
+ if (lineangle ==null || linelength== null )
+ {
+ //toptext = "";
+ //bottomtext = "";
+ lineangle = 0.0;
+ linelength = 0;
+ }
+
+
+
+ Object o = vertexIdMap.get(id);
+ if (o == null) {
+ System.out.println("Undefined Vertex: " + id);
+ continue;
+ }
+ Label l = new Label(shape,
+ shapesize ,
+ shapeboarderwidth ,
+ shapebordercolor,
+ shapefillcolor ,
+ shapefillopacity ,
+ linesize ,
+ linelength ,
+ lineangle ,
+ linecolor,
+ toptextttf,
+ toptextsize ,
+ toptextcolor ,
+ topbgfillcolor ,
+ bottomtextttf ,
+ bottomtextsize ,
+ bottomtextcolor ,
+ bottombgfillcolor ,
+ toptext,
+ bottomtext);
+ labelMap.put((Vertex) o,l);
+
+ }
+
+ }
+
+
// //////////////////////////////////////////////////////////
// ACCESSORS
// //////////////////////////////////////////////////////////
@@ -256,6 +426,11 @@ public Vertex[] getVertices() {
return vertices;
}
+ public HashMap getLabels() {
+ return labelMap;
+ }
+
+
public HashMap getEdgeColorMap() {
return edgeColorMap;
}
@@ -345,6 +520,37 @@ private Color readColorRGB(int index) {
return new Color((float) r, (float) g, (float) b);
}
+ private Color readColorRGBHex(int index) {
+ String hex = fileio.getToken(index);
+ try
+ {
+ int code = Integer.parseInt(hex,16);
+
+ return new Color((float) (code >> 16)/255, (float) ((code >> 8) & 255)/255, (float) (code & 255)/255);
+ }
+ catch (NumberFormatException nfe) {
+ return null;
+ }
+ }
+
+ private Color readColorRGBHexAlpha(int index) {
+ String hex = fileio.getToken(index++);
+ try
+ {
+ int code = Integer.parseInt(hex,16);
+ Double d = fileio.getTokenAsDouble(index);
+ if (d==null)
+ return null;
+ float alpha = (float) d.floatValue();
+ return new Color((float) (code >> 16)/255, (float) ((code >> 8) & 255)/255, (float) (code & 255)/255,alpha/100);
+ }
+ catch (NumberFormatException nfe) {
+ return null;
+ }
+
+ }
+
+
private void tidyNewVerticesAndEdges() {
// This just loads the edges into an array and out of the
// vector
@@ -363,4 +569,6 @@ private void tidyNewVerticesAndEdges() {
}
verticesV.clear();
}
+
+
}
diff --git a/Java/src/Viewer2D/icons8-magnifier-67_32x32.png b/Java/src/Viewer2D/icons8-magnifier-67_32x32.png
new file mode 100644
index 00000000..a735819b
Binary files /dev/null and b/Java/src/Viewer2D/icons8-magnifier-67_32x32.png differ
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/Document.java b/Java/src/de/erichseifert/vectorgraphics2d/Document.java
new file mode 100644
index 00000000..283f4777
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/Document.java
@@ -0,0 +1,39 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * Interface for documents that are able to output binary files in the
+ * implemented file format.
+ */
+public interface Document {
+ void writeTo(OutputStream out) throws IOException;
+
+ /**
+ * Returns whether or not the {@code Document} represents compressed data.
+ * @return {@code true} if the contents are compressed, {@code false} otherwise.
+ */
+ boolean isCompressed();
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/GraphicsState.java b/Java/src/de/erichseifert/vectorgraphics2d/GraphicsState.java
new file mode 100644
index 00000000..5fc442f1
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/GraphicsState.java
@@ -0,0 +1,255 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d;
+
+import java.awt.AlphaComposite;
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.Font;
+import java.awt.Paint;
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.Stroke;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.geom.Rectangle2D;
+
+import de.erichseifert.vectorgraphics2d.util.GraphicsUtils;
+
+/**
+ * Representation of the Graphics2D status at a certain point in time.
+ */
+public class GraphicsState implements Cloneable {
+ /** Default background color. */
+ public static final Color DEFAULT_BACKGROUND = Color.BLACK;
+ /** Default color. */
+ public static final Color DEFAULT_COLOR = Color.WHITE;
+ /** Default clipping shape. */
+ public static final Shape DEFAULT_CLIP = null;
+ /** Default composite mode. */
+ public static final Composite DEFAULT_COMPOSITE = AlphaComposite.SrcOver;
+ /** Default font. */
+ public static final Font DEFAULT_FONT = Font.decode(null);
+ /** Default paint. */
+ public static final Color DEFAULT_PAINT = DEFAULT_COLOR;
+ /** Default stroke. */
+ public static final Stroke DEFAULT_STROKE = new BasicStroke();
+ /** Default transformation. */
+ public static final AffineTransform DEFAULT_TRANSFORM =
+ new AffineTransform();
+ /** Default XOR mode. */
+ public static final Color DEFAULT_XOR_MODE = Color.BLACK;
+
+ /** Rendering hints. */
+ private RenderingHints hints;
+ /** Current background color. */
+ private Color background;
+ /** Current foreground color. */
+ private Color color;
+ /** Shape used for clipping paint operations. */
+ private Shape clip;
+ /** Method used for compositing. */
+ private Composite composite;
+ /** Current font. */
+ private Font font;
+ /** Paint used to fill shapes. */
+ private Paint paint;
+ /** Stroke used for drawing shapes. */
+ private Stroke stroke;
+ /** Current transformation matrix. */
+ private AffineTransform transform;
+ /** XOR mode used for rendering. */
+ private Color xorMode;
+
+ public GraphicsState() {
+ hints = new RenderingHints(null);
+ background = DEFAULT_BACKGROUND;
+ color = DEFAULT_COLOR;
+ clip = DEFAULT_CLIP;
+ composite = DEFAULT_COMPOSITE;
+ font = DEFAULT_FONT;
+ paint = DEFAULT_PAINT;
+ stroke = DEFAULT_STROKE;
+ transform = new AffineTransform(DEFAULT_TRANSFORM);
+ xorMode = DEFAULT_XOR_MODE;
+ }
+
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ GraphicsState clone = (GraphicsState) super.clone();
+ clone.hints = (RenderingHints) hints.clone();
+ clone.clip = GraphicsUtils.clone(clip);
+ clone.transform = new AffineTransform(transform);
+ return clone;
+ }
+
+ private static Shape transformShape(Shape s, AffineTransform tx) {
+ if (s == null) {
+ return null;
+ }
+ if (tx == null || tx.isIdentity()) {
+ return GraphicsUtils.clone(s);
+ }
+ boolean isRectangle = s instanceof Rectangle2D;
+ int nonRectlinearTxMask = AffineTransform.TYPE_GENERAL_TRANSFORM |
+ AffineTransform.TYPE_GENERAL_ROTATION;
+ boolean isRectlinearTx = (tx.getType() & nonRectlinearTxMask) == 0;
+ if (isRectangle && isRectlinearTx) {
+ Rectangle2D rect = (Rectangle2D) s;
+ double[] corners = new double[] {
+ rect.getMinX(), rect.getMinY(),
+ rect.getMaxX(), rect.getMaxY()
+ };
+ tx.transform(corners, 0, corners, 0, 2);
+ rect = new Rectangle2D.Double();
+ rect.setFrameFromDiagonal(corners[0], corners[1], corners[2],
+ corners[3]);
+ return rect;
+ }
+ return tx.createTransformedShape(s);
+ }
+
+ private static Shape untransformShape(Shape s, AffineTransform tx) {
+ if (s == null) {
+ return null;
+ }
+ try {
+ AffineTransform inverse = tx.createInverse();
+ return transformShape(s, inverse);
+ } catch (NoninvertibleTransformException e) {
+ return null;
+ }
+ }
+
+ public Shape transformShape(Shape shape) {
+ return transformShape(shape, transform);
+ }
+
+ public Shape untransformShape(Shape shape) {
+ return untransformShape(shape, transform);
+ }
+
+ public RenderingHints getHints() {
+ return hints;
+ }
+
+ public Color getBackground() {
+ return background;
+ }
+
+ public void setBackground(Color background) {
+ this.background = background;
+ }
+
+ public Color getColor() {
+ return color;
+ }
+
+ public void setColor(Color color) {
+ this.color = color;
+ }
+
+ public Shape getClip() {
+ return untransformShape(clip);
+ }
+
+ public void setClip(Shape clip) {
+ this.clip = transformShape(clip);
+ }
+
+ public Composite getComposite() {
+ return composite;
+ }
+
+ public void setComposite(Composite composite) {
+ this.composite = composite;
+ }
+
+ public Font getFont() {
+ return font;
+ }
+
+ public void setFont(Font font) {
+ this.font = font;
+ }
+
+ public Paint getPaint() {
+ return paint;
+ }
+
+ public void setPaint(Paint paint) {
+ this.paint = paint;
+ }
+
+ public Stroke getStroke() {
+ return stroke;
+ }
+
+ public void setStroke(Stroke stroke) {
+ this.stroke = stroke;
+ }
+
+ public AffineTransform getTransform() {
+ return new AffineTransform(transform);
+ }
+
+ public void setTransform(AffineTransform tx) {
+ transform.setTransform(tx);
+ }
+
+ public Color getXorMode() {
+ return xorMode;
+ }
+
+ public void setXorMode(Color xorMode) {
+ this.xorMode = xorMode;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof GraphicsState)) {
+ return false;
+ }
+ GraphicsState o = (GraphicsState) obj;
+ // Compare all attributes
+ return !(!hints.equals(o.hints) || !background.equals(o.background) ||
+ !color.equals(o.color) || !composite.equals(o.composite) ||
+ !font.equals(o.font) || !paint.equals(o.paint) ||
+ !stroke.equals(o.stroke) || !transform.equals(o.transform) ||
+ !xorMode.equals(o.xorMode) ||
+ ((clip == null || o.clip == null) && clip != o.clip) ||
+ (clip != null && !clip.equals(o.clip)));
+ }
+
+ public boolean isDefault() {
+ return hints.isEmpty() && background.equals(DEFAULT_BACKGROUND) &&
+ color.equals(DEFAULT_COLOR) && composite.equals(DEFAULT_COMPOSITE) &&
+ font.equals(DEFAULT_FONT) && paint.equals(DEFAULT_PAINT) &&
+ stroke.equals(DEFAULT_STROKE) && transform.equals(DEFAULT_TRANSFORM) &&
+ xorMode.equals(DEFAULT_XOR_MODE) && clip == DEFAULT_CLIP;
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/Processor.java b/Java/src/de/erichseifert/vectorgraphics2d/Processor.java
new file mode 100644
index 00000000..b40a0cfb
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/Processor.java
@@ -0,0 +1,39 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d;
+
+import de.erichseifert.vectorgraphics2d.intermediate.CommandSequence;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.Command;
+import de.erichseifert.vectorgraphics2d.util.PageSize;
+
+/**
+ * Translates {@link Command} objects into a {@link Document}.
+ */
+public interface Processor {
+ /**
+ * Constructs a {@code Document} from the specified commands.
+ * @param commands Commands used to create the {@code Document}.
+ * @param pageSize Size of the resulting {@code Document}.
+ * @return {@code Document} representation of the commands.
+ */
+ Document getDocument(CommandSequence commands, PageSize pageSize);
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/Processors.java b/Java/src/de/erichseifert/vectorgraphics2d/Processors.java
new file mode 100644
index 00000000..5fffcc69
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/Processors.java
@@ -0,0 +1,59 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d;
+
+import de.erichseifert.vectorgraphics2d.eps.EPSProcessor;
+import de.erichseifert.vectorgraphics2d.pdf.PDFProcessor;
+import de.erichseifert.vectorgraphics2d.svg.SVGProcessor;
+
+/**
+ *
Utility class that provides simplified access to processors for different
+ * file formats. At the moment three implementations of processors are available:
+ * {@code "eps"}, {@code "pdf"}, and {@code "svg"}
+ *
A new processor can be retrieved by calling the {@link #get(String)}
+ * method with the format name:
+ *
Processor pdfProcessor = Processors.get("pdf");
+ */
+public abstract class Processors {
+ /**
+ * Default constructor that prevents creation of class.
+ */
+ Processors() {
+ throw new UnsupportedOperationException();
+ }
+
+ public static Processor get(String format) {
+ if (format == null) {
+ throw new NullPointerException("Format cannot be null.");
+ }
+ switch (format) {
+ case "eps":
+ return new EPSProcessor();
+ case "pdf":
+ return new PDFProcessor(true);
+ case "svg":
+ return new SVGProcessor();
+ default:
+ throw new IllegalArgumentException("Unknown format \"" + format + "\"");
+ }
+ }
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/SizedDocument.java b/Java/src/de/erichseifert/vectorgraphics2d/SizedDocument.java
new file mode 100644
index 00000000..9c4129aa
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/SizedDocument.java
@@ -0,0 +1,46 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d;
+
+import de.erichseifert.vectorgraphics2d.util.PageSize;
+
+/**
+ * Abstract base for documents that are restricted to a specified page size.
+ */
+public abstract class SizedDocument implements Document {
+ private final PageSize pageSize;
+ private final boolean compressed;
+
+ public SizedDocument(PageSize pageSize, boolean compressed) {
+ this.pageSize = pageSize;
+ this.compressed = compressed;
+ }
+
+ public PageSize getPageSize() {
+ return pageSize;
+ }
+
+ @Override
+ public boolean isCompressed() {
+ return this.compressed;
+ }
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/VectorGraphics2D.java b/Java/src/de/erichseifert/vectorgraphics2d/VectorGraphics2D.java
new file mode 100644
index 00000000..864e3074
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/VectorGraphics2D.java
@@ -0,0 +1,804 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d;
+
+import java.awt.AlphaComposite;
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import java.awt.Image;
+import java.awt.Paint;
+import java.awt.Polygon;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.RenderingHints.Key;
+import java.awt.Shape;
+import java.awt.Stroke;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.font.TextLayout;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Arc2D;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.RoundRectangle2D;
+import java.awt.image.AffineTransformOp;
+import java.awt.image.BufferedImage;
+import java.awt.image.BufferedImageOp;
+import java.awt.image.ImageObserver;
+import java.awt.image.RenderedImage;
+import java.awt.image.renderable.RenderableImage;
+import java.text.AttributedCharacterIterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import de.erichseifert.vectorgraphics2d.intermediate.CommandSequence;
+import de.erichseifert.vectorgraphics2d.intermediate.MutableCommandSequence;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.Command;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.CreateCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DisposeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DrawImageCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DrawShapeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DrawStringCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.FillShapeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.RotateCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.ScaleCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetBackgroundCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetClipCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetColorCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetCompositeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetFontCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetHintCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetPaintCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetStrokeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetTransformCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetXORModeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.ShearCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.TransformCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.TranslateCommand;
+import de.erichseifert.vectorgraphics2d.util.GraphicsUtils;
+
+/**
+ *
Implementation of the Graphics2D interface to Java to generate a sequence of
+ * commands. An instance of {@code VectorGraphics2D} can be used to replace any
+ * {@code Graphics2D} object. It can be created with its standard constructor:
+ *
Graphics2D g = new VectorGraphics2D();
+ *
+ * @see http://www.java2s.com/Code/Java/2D-Graphics-GUI/YourownGraphics2D.htm
+ */
+public class VectorGraphics2D extends Graphics2D implements Cloneable {
+ private final MutableCommandSequence commands;
+ /** Device configuration settings. */
+ private final GraphicsConfiguration deviceConfig;
+ /** Context settings used to render fonts. */
+ private final FontRenderContext fontRenderContext;
+ /** Flag that tells whether this graphics object has been disposed. */
+ private boolean disposed;
+
+ private GraphicsState state;
+
+ public VectorGraphics2D() {
+ this.commands = new MutableCommandSequence();
+ emit(new CreateCommand(this));
+ GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
+ if (!graphicsEnvironment.isHeadlessInstance()) {
+ GraphicsDevice graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
+ deviceConfig = graphicsDevice.getDefaultConfiguration();
+ } else {
+ deviceConfig = null;
+ }
+ fontRenderContext = new FontRenderContext(null, false, true);
+
+ state = new GraphicsState();
+
+ // Ensure that document state matches default state of Graphics2D
+ // TODO: Default graphics state does not need to be printed in the document.
+ // Use filters in the appropriate documents
+ setColor(Color.BLACK); // Required for EPS, PDF, and SVG
+ setStroke(new BasicStroke(1f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10f, null, 0f)); // EPS and PDF
+ }
+
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ VectorGraphics2D clone = (VectorGraphics2D) super.clone();
+ clone.state = (GraphicsState) state.clone();
+ return clone;
+ }
+
+ @Override
+ public void addRenderingHints(Map hints) {
+ if (isDisposed()) {
+ return;
+ }
+ for (Entry entry : hints.entrySet()) {
+ setRenderingHint((Key) entry.getKey(), entry.getValue());
+ }
+ }
+
+ @Override
+ public void clip(Shape s) {
+ Shape clip = getClip();
+ if ((clip != null) && (s != null)) {
+ s = intersectShapes(clip, s);
+ }
+ setClip(s);
+ }
+
+ private static Shape intersectShapes(Shape s1, Shape s2) {
+ if (s1 instanceof Rectangle2D && s2 instanceof Rectangle2D) {
+ Rectangle2D r1 = (Rectangle2D) s1;
+ Rectangle2D r2 = (Rectangle2D) s2;
+ double x1 = Math.max(r1.getMinX(), r2.getMinX());
+ double y1 = Math.max(r1.getMinY(), r2.getMinY());
+ double x2 = Math.min(r1.getMaxX(), r2.getMaxX());
+ double y2 = Math.min(r1.getMaxY(), r2.getMaxY());
+
+ Rectangle2D intersection = new Rectangle2D.Double();
+ if ((x2 < x1) || (y2 < y1)) {
+ intersection.setFrameFromDiagonal(0, 0, 0, 0);
+ } else {
+ intersection.setFrameFromDiagonal(x1, y1, x2, y2);
+ }
+ return intersection;
+ } else {
+ Area intersection = new Area(s1);
+ intersection.intersect(new Area(s2));
+ return intersection;
+ }
+ }
+
+ @Override
+ public void draw(Shape s) {
+ if (isDisposed() || s == null) {
+ return;
+ }
+ emit(new DrawShapeCommand(s));
+ }
+
+ @Override
+ public void drawGlyphVector(GlyphVector g, float x, float y) {
+ Shape s = g.getOutline(x, y);
+ draw(s);
+ }
+
+ @Override
+ public boolean drawImage(Image img, AffineTransform xform, ImageObserver obs) {
+ BufferedImage bimg = getTransformedImage(img, xform);
+ return drawImage(bimg, bimg.getMinX(), bimg.getMinY(),
+ bimg.getWidth(), bimg.getHeight(), null, null);
+ }
+
+ /**
+ * Returns a transformed version of an image.
+ * @param image Image to be transformed
+ * @param xform Affine transform to be applied
+ * @return Image with transformed content
+ */
+ private BufferedImage getTransformedImage(Image image,
+ AffineTransform xform) {
+ Integer interpolationType =
+ (Integer) getRenderingHint(RenderingHints.KEY_INTERPOLATION);
+ if (RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR
+ .equals(interpolationType)) {
+ interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
+ } else if (RenderingHints.VALUE_INTERPOLATION_BILINEAR
+ .equals(interpolationType)) {
+ interpolationType = AffineTransformOp.TYPE_BILINEAR;
+ } else {
+ interpolationType = AffineTransformOp.TYPE_BICUBIC;
+ }
+ AffineTransformOp op = new AffineTransformOp(xform, interpolationType);
+ BufferedImage bufferedImage = GraphicsUtils.toBufferedImage(image);
+ return op.filter(bufferedImage, null);
+ }
+
+ @Override
+ public void drawImage(BufferedImage img, BufferedImageOp op, int x, int y) {
+ if (op != null) {
+ img = op.filter(img, null);
+ }
+ drawImage(img, x, y, img.getWidth(), img.getHeight(), null, null);
+ }
+
+ @Override
+ public void drawRenderableImage(RenderableImage img, AffineTransform xform) {
+ drawRenderedImage(img.createDefaultRendering(), xform);
+ }
+
+ @Override
+ public void drawRenderedImage(RenderedImage img, AffineTransform xform) {
+ BufferedImage bimg = GraphicsUtils.toBufferedImage(img);
+ drawImage(bimg, xform, null);
+ }
+
+ @Override
+ public void drawString(String str, int x, int y) {
+ drawString(str, (float) x, (float) y);
+ }
+
+ @Override
+ public void drawString(String str, float x, float y) {
+ if (isDisposed() || str == null || str.trim().length() == 0) {
+ return;
+ }
+ boolean isTextAsVectors = false;
+ if (isTextAsVectors) {
+ TextLayout layout = new TextLayout(str, getFont(),
+ getFontRenderContext());
+ Shape s = layout.getOutline(
+ AffineTransform.getTranslateInstance(x, y));
+ fill(s);
+ } else {
+ emit(new DrawStringCommand(str, x, y));
+ }
+
+ }
+
+ @Override
+ public void drawString(AttributedCharacterIterator iterator, int x, int y) {
+ drawString(iterator, (float) x, (float) y);
+ }
+
+ @Override
+ public void drawString(AttributedCharacterIterator iterator, float x,
+ float y) {
+ // TODO Draw styled text
+ StringBuilder buf = new StringBuilder();
+ for (char c = iterator.first(); c != AttributedCharacterIterator.DONE;
+ c = iterator.next()) {
+ buf.append(c);
+ }
+ drawString(buf.toString(), x, y);
+ }
+
+ @Override
+ public void fill(Shape s) {
+ if (isDisposed() || s == null) {
+ return;
+ }
+ emit(new FillShapeCommand(s));
+ }
+
+ @Override
+ public Color getBackground() {
+ return state.getBackground();
+ }
+
+ @Override
+ public Composite getComposite() {
+ return state.getComposite();
+ }
+
+ @Override
+ public GraphicsConfiguration getDeviceConfiguration() {
+ return deviceConfig;
+ }
+
+ @Override
+ public FontRenderContext getFontRenderContext() {
+ return fontRenderContext;
+ }
+
+ @Override
+ public Paint getPaint() {
+ return state.getPaint();
+ }
+
+ @Override
+ public Object getRenderingHint(Key hintKey) {
+ if (RenderingHints.KEY_ANTIALIASING.equals(hintKey)) {
+ return RenderingHints.VALUE_ANTIALIAS_OFF;
+ } else if (RenderingHints.KEY_TEXT_ANTIALIASING.equals(hintKey)) {
+ return RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
+ } else if (RenderingHints.KEY_FRACTIONALMETRICS.equals(hintKey)) {
+ return RenderingHints.VALUE_FRACTIONALMETRICS_ON;
+ }
+ return state.getHints().get(hintKey);
+ }
+
+ @Override
+ public RenderingHints getRenderingHints() {
+ return (RenderingHints) state.getHints().clone();
+ }
+
+ @Override
+ public Stroke getStroke() {
+ return state.getStroke();
+ }
+
+ @Override
+ public boolean hit(Rectangle rect, Shape s, boolean onStroke) {
+ Shape hitShape = s;
+ if (onStroke) {
+ hitShape = getStroke().createStrokedShape(hitShape);
+ }
+ hitShape = state.transformShape(hitShape);
+ return hitShape.intersects(rect);
+ }
+
+ @Override
+ public void setBackground(Color color) {
+ if (isDisposed() || color == null || getColor().equals(color)) {
+ return;
+ }
+ emit(new SetBackgroundCommand(color));
+ state.setBackground(color);
+ }
+
+ @Override
+ public void setComposite(Composite comp) {
+ if (isDisposed()) {
+ return;
+ }
+ if (comp == null) {
+ throw new IllegalArgumentException("Cannot set a null composite.");
+ }
+ emit(new SetCompositeCommand(comp));
+ state.setComposite(comp);
+ }
+
+ @Override
+ public void setPaint(Paint paint) {
+ if (isDisposed() || paint == null) {
+ return;
+ }
+ if (paint instanceof Color) {
+ setColor((Color) paint);
+ return;
+ }
+ if (getPaint().equals(paint)) {
+ return;
+ }
+ emit(new SetPaintCommand(paint));
+ state.setPaint(paint);
+ }
+
+ @Override
+ public void setRenderingHint(Key hintKey, Object hintValue) {
+ if (isDisposed()) {
+ return;
+ }
+ state.getHints().put(hintKey, hintValue);
+ emit(new SetHintCommand(hintKey, hintValue));
+ }
+
+ @Override
+ public void setRenderingHints(Map hints) {
+ if (isDisposed()) {
+ return;
+ }
+ state.getHints().clear();
+ for (Entry hint : hints.entrySet()) {
+ setRenderingHint((Key) hint.getKey(), hint.getValue());
+ }
+ }
+
+ @Override
+ public void setStroke(Stroke s) {
+ if (isDisposed()) {
+ return;
+ }
+ if (s == null) {
+ throw new IllegalArgumentException("Cannot set a null stroke.");
+ }
+ emit(new SetStrokeCommand(s));
+ state.setStroke(s);
+ }
+
+ @Override
+ public AffineTransform getTransform() {
+ return new AffineTransform(state.getTransform());
+ }
+
+ @Override
+ public void setTransform(AffineTransform tx) {
+ if (isDisposed() || tx == null || state.getTransform().equals(tx)) {
+ return;
+ }
+ emit(new SetTransformCommand(tx));
+ state.setTransform(tx);
+ }
+
+ @Override
+ public void shear(double shx, double shy) {
+ if (shx == 0.0 && shy == 0.0) {
+ return;
+ }
+ AffineTransform txNew = getTransform();
+ txNew.shear(shx, shy);
+ emit(new ShearCommand(shx, shy));
+ state.setTransform(txNew);
+ }
+
+ @Override
+ public void transform(AffineTransform tx) {
+ if (tx.isIdentity()) {
+ return;
+ }
+ AffineTransform txNew = getTransform();
+ txNew.concatenate(tx);
+ emit(new TransformCommand(tx));
+ state.setTransform(txNew);
+ }
+
+ @Override
+ public void translate(int x, int y) {
+ translate((double) x, (double) y);
+ }
+
+ @Override
+ public void translate(double tx, double ty) {
+ if (tx == 0.0 && ty == 0.0) {
+ return;
+ }
+ AffineTransform txNew = getTransform();
+ txNew.translate(tx, ty);
+ emit(new TranslateCommand(tx, ty));
+ state.setTransform(txNew);
+ }
+
+ @Override
+ public void rotate(double theta) {
+ rotate(theta, 0.0, 0.0);
+ }
+
+ @Override
+ public void rotate(double theta, double x, double y) {
+ if (theta == 0.0) {
+ return;
+ }
+
+ AffineTransform txNew = getTransform();
+ if (x == 0.0 && y == 0.0) {
+ txNew.rotate(theta);
+ } else {
+ txNew.rotate(theta, x, y);
+ }
+
+ emit(new RotateCommand(theta, x, y));
+ state.setTransform(txNew);
+ }
+
+ @Override
+ public void scale(double sx, double sy) {
+ if (sx == 1.0 && sy == 1.0) {
+ return;
+ }
+ AffineTransform txNew = getTransform();
+ txNew.scale(sx, sy);
+ emit(new ScaleCommand(sx, sy));
+ state.setTransform(txNew);
+ }
+
+ @Override
+ public void clearRect(int x, int y, int width, int height) {
+ Color colorOld = getColor();
+ setColor(getBackground());
+ fillRect(x, y, width, height);
+ setColor(colorOld);
+ }
+
+ @Override
+ public void clipRect(int x, int y, int width, int height) {
+ clip(new Rectangle(x, y, width, height));
+ }
+
+ @Override
+ public void copyArea(int x, int y, int width, int height, int dx, int dy) {
+ // TODO Implement
+ //throw new UnsupportedOperationException("copyArea() isn't supported by VectorGraphics2D.");
+ }
+
+ @Override
+ public Graphics create() {
+ if (isDisposed()) {
+ return null;
+ }
+ VectorGraphics2D clone = null;
+ try {
+ clone = (VectorGraphics2D) this.clone();
+ emit(new CreateCommand(clone));
+ } catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+ }
+ return clone;
+ }
+
+ @Override
+ public void dispose() {
+ if (isDisposed()) {
+ return;
+ }
+
+ emit(new DisposeCommand(this));
+
+ disposed = true;
+ }
+
+ @Override
+ public void drawArc(int x, int y, int width, int height, int startAngle,
+ int arcAngle) {
+ draw(new Arc2D.Double(x, y, width, height,
+ startAngle, arcAngle, Arc2D.OPEN));
+ }
+
+ @Override
+ public boolean drawImage(Image img, int x, int y, ImageObserver observer) {
+ return drawImage(img, x, y, img.getWidth(observer),
+ img.getHeight(observer), null, observer);
+ }
+
+ @Override
+ public boolean drawImage(Image img, int x, int y, Color bgcolor,
+ ImageObserver observer) {
+ return drawImage(img, x, y, img.getWidth(observer),
+ img.getHeight(observer), bgcolor, observer);
+ }
+
+ @Override
+ public boolean drawImage(Image img, int x, int y, int width, int height,
+ ImageObserver observer) {
+ return drawImage(img, x, y, width, height, null, observer);
+ }
+
+ @Override
+ public boolean drawImage(Image img, int x, int y, int width, int height,
+ Color bgcolor, ImageObserver observer) {
+ if (isDisposed() || img == null) {
+ return true;
+ }
+
+ int imageWidth = img.getWidth(observer);
+ int imageHeight = img.getHeight(observer);
+ Rectangle bounds = new Rectangle(x, y, width, height);
+
+ if (bgcolor != null) {
+ // Fill rectangle with bgcolor
+ Color bgcolorOld = getColor();
+ setColor(bgcolor);
+ fill(bounds);
+ setColor(bgcolorOld);
+ }
+
+ emit(new DrawImageCommand(img, imageWidth, imageHeight, x, y, width, height));
+ return true;
+ }
+
+ @Override
+ public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2,
+ int sx1, int sy1, int sx2, int sy2, ImageObserver observer) {
+ return drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null,
+ observer);
+ }
+
+ @Override
+ public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2,
+ int sx1, int sy1, int sx2, int sy2, Color bgcolor,
+ ImageObserver observer) {
+ if (img == null) {
+ return true;
+ }
+
+ int sx = Math.min(sx1, sx2);
+ int sy = Math.min(sy1, sy2);
+ int sw = Math.abs(sx2 - sx1);
+ int sh = Math.abs(sy2 - sy1);
+ int dx = Math.min(dx1, dx2);
+ int dy = Math.min(dy1, dy2);
+ int dw = Math.abs(dx2 - dx1);
+ int dh = Math.abs(dy2 - dy1);
+
+ // Draw image on rectangle
+ BufferedImage bufferedImg = GraphicsUtils.toBufferedImage(img);
+ Image cropped = bufferedImg.getSubimage(sx, sy, sw, sh);
+ return drawImage(cropped, dx, dy, dw, dh, bgcolor, observer);
+ }
+
+ @Override
+ public void drawLine(int x1, int y1, int x2, int y2) {
+ draw(new Line2D.Double(x1, y1, x2, y2));
+ }
+
+ @Override
+ public void drawOval(int x, int y, int width, int height) {
+ draw(new Ellipse2D.Double(x, y, width, height));
+ }
+
+ @Override
+ public void drawPolygon(Polygon p) {
+ draw(p);
+ }
+
+ @Override
+ public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) {
+ draw(new Polygon(xPoints, yPoints, nPoints));
+ }
+
+ @Override
+ public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) {
+ Path2D p = new Path2D.Float();
+ for (int i = 0; i < nPoints; i++) {
+ if (i > 0) {
+ p.lineTo(xPoints[i], yPoints[i]);
+ } else {
+ p.moveTo(xPoints[i], yPoints[i]);
+ }
+ }
+ draw(p);
+ }
+
+ @Override
+ public void drawRect(int x, int y, int width, int height) {
+ draw(new Rectangle(x, y, width, height));
+ }
+
+ @Override
+ public void drawRoundRect(int x, int y, int width, int height,
+ int arcWidth, int arcHeight) {
+ draw(new RoundRectangle2D.Double(x, y, width, height,
+ arcWidth, arcHeight));
+ }
+
+ @Override
+ public void fillArc(int x, int y, int width, int height,
+ int startAngle, int arcAngle) {
+ fill(new Arc2D.Double(x, y, width, height,
+ startAngle, arcAngle, Arc2D.PIE));
+ }
+
+ @Override
+ public void fillOval(int x, int y, int width, int height) {
+ fill(new Ellipse2D.Double(x, y, width, height));
+ }
+
+ @Override
+ public void fillPolygon(Polygon p) {
+ fill(p);
+ }
+
+ @Override
+ public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints) {
+ fill(new Polygon(xPoints, yPoints, nPoints));
+ }
+
+ @Override
+ public void fillRect(int x, int y, int width, int height) {
+ fill(new Rectangle(x, y, width, height));
+ }
+
+ @Override
+ public void fillRoundRect(int x, int y, int width, int height,
+ int arcWidth, int arcHeight) {
+ fill(new RoundRectangle2D.Double(x, y, width, height,
+ arcWidth, arcHeight));
+ }
+
+ @Override
+ public Shape getClip() {
+ return state.getClip();
+ }
+
+ @Override
+ public Rectangle getClipBounds() {
+ if (getClip() == null) {
+ return null;
+ }
+ return getClip().getBounds();
+ }
+
+ @Override
+ public Color getColor() {
+ return state.getColor();
+ }
+
+ @Override
+ public Font getFont() {
+ return state.getFont();
+ }
+
+ @Override
+ public FontMetrics getFontMetrics(Font f) {
+ BufferedImage bi =
+ new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB_PRE);
+ Graphics g = bi.getGraphics();
+ FontMetrics fontMetrics = g.getFontMetrics(f);
+ g.dispose();
+ return fontMetrics;
+ }
+
+ @Override
+ public void setClip(Shape clip) {
+ if (isDisposed()) {
+ return;
+ }
+ emit(new SetClipCommand(clip));
+ state.setClip(clip);
+ }
+
+ @Override
+ public void setClip(int x, int y, int width, int height) {
+ setClip(new Rectangle(x, y, width, height));
+ }
+
+ @Override
+ public void setColor(Color c) {
+ if (isDisposed() || c == null || getColor().equals(c)) {
+ return;
+ }
+ emit(new SetColorCommand(c));
+ state.setColor(c);
+ state.setPaint(c);
+ }
+
+ @Override
+ public void setFont(Font font) {
+ if (isDisposed() || (font != null && getFont().equals(font))) {
+ return;
+ }
+ emit(new SetFontCommand(font));
+ state.setFont(font);
+ }
+
+ @Override
+ public void setPaintMode() {
+ setComposite(AlphaComposite.SrcOver);
+ }
+
+ public Color getXORMode() {
+ return state.getXorMode();
+ }
+
+ @Override
+ public void setXORMode(Color c1) {
+ if (isDisposed() || c1 == null) {
+ return;
+ }
+ emit(new SetXORModeCommand(c1));
+ state.setXorMode(c1);
+ }
+
+ private void emit(Command command) {
+ commands.add(command);
+ }
+
+ protected boolean isDisposed() {
+ return disposed;
+ }
+
+ /**
+ * Returns a {@code CommandSequence} representing all calls that were issued to this {@code VectorGraphics2D} object.
+ * @return Sequence of commands since.
+ */
+ public CommandSequence getCommands() {
+ return commands;
+ }
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/VectorHints.java b/Java/src/de/erichseifert/vectorgraphics2d/VectorHints.java
new file mode 100644
index 00000000..09eabe41
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/VectorHints.java
@@ -0,0 +1,117 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d;
+
+import java.awt.RenderingHints;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Hints to control quality settings and choices for vector graphics output.
+ */
+public abstract class VectorHints {
+ protected VectorHints() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Base type of all keys used along with the {@link VectorHints} class to
+ * control algorithm and output choices in the vector graphics output.
+ */
+ public static class Key extends RenderingHints.Key {
+ private final String description;
+
+ public Key(int privateKey, String description) {
+ super(privateKey);
+ this.description = description;
+ }
+
+ public int getIndex() {
+ return intKey();
+ }
+
+ @Override
+ public boolean isCompatibleValue(Object val) {
+ return val instanceof Value && ((Value) val).isCompatibleKey(this);
+ }
+
+ @Override
+ public String toString() {
+ return description;
+ }
+ }
+
+ /**
+ * Base type of all values used along with the {@link VectorHints} class to
+ * control algorithm and output choices in the vector graphics output.
+ */
+ public static class Value {
+ private static final Set values = new HashSet<>();
+
+ private synchronized static void register(Value value) {
+ String id = value.getId();
+ if (values.contains(id)) {
+ throw new ExceptionInInitializerError(
+ "Duplicate index: "+value.getIndex());
+ }
+ values.add(id);
+ }
+
+ private final Key key;
+ private final int index;
+ private final String description;
+
+ public Value(Key key, int index, String description) {
+ this.key = key;
+ this.index = index;
+ this.description = description;
+ register(this);
+ }
+
+ public boolean isCompatibleKey(RenderingHints.Key key) {
+ return this.key == key;
+ }
+
+ public int getIndex() {
+ return index;
+ }
+
+ public String getId() {
+ return key.getIndex()+":"+getIndex();
+ }
+
+ @Override
+ public String toString() {
+ return description;
+ }
+ }
+
+ public static final Key KEY_EXPORT = new Key(0, "Vector export mode");
+ public static final Object VALUE_EXPORT_READABILITY = new Value(KEY_EXPORT, 0, "Maximize readability for humans");
+ public static final Object VALUE_EXPORT_QUALITY = new Value(KEY_EXPORT, 1, "Maximize render quality");
+ public static final Object VALUE_EXPORT_SIZE = new Value(KEY_EXPORT, 2, "Minimize data size");
+
+ public static final Key KEY_TEXT = new Key(1, "Text export mode");
+ public static final Object VALUE_TEXT_DEFAULT = new Value(KEY_TEXT, 0, "Keep text");
+ public static final Object VALUE_TEXT_VECTOR = new Value(KEY_TEXT, 1, "Convert text to vector shapes");
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/eps/EPSDocument.java b/Java/src/de/erichseifert/vectorgraphics2d/eps/EPSDocument.java
new file mode 100644
index 00000000..249a0f70
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/eps/EPSDocument.java
@@ -0,0 +1,515 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.eps;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Image;
+import java.awt.Shape;
+import java.awt.Stroke;
+import java.awt.color.ColorSpace;
+import java.awt.geom.Arc2D;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import de.erichseifert.vectorgraphics2d.GraphicsState;
+import de.erichseifert.vectorgraphics2d.SizedDocument;
+import de.erichseifert.vectorgraphics2d.intermediate.CommandSequence;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.Command;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.CreateCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DisposeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DrawImageCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DrawShapeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.DrawStringCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.FillShapeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.RotateCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.ScaleCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetClipCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetColorCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetCompositeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetFontCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetPaintCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetStrokeCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.SetTransformCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.ShearCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.TransformCommand;
+import de.erichseifert.vectorgraphics2d.intermediate.commands.TranslateCommand;
+import de.erichseifert.vectorgraphics2d.util.ASCII85EncodeStream;
+import de.erichseifert.vectorgraphics2d.util.AlphaToMaskOp;
+import de.erichseifert.vectorgraphics2d.util.DataUtils;
+import de.erichseifert.vectorgraphics2d.util.FlateEncodeStream;
+import de.erichseifert.vectorgraphics2d.util.GraphicsUtils;
+import de.erichseifert.vectorgraphics2d.util.ImageDataStream;
+import de.erichseifert.vectorgraphics2d.util.ImageDataStream.Interleaving;
+import de.erichseifert.vectorgraphics2d.util.LineWrapOutputStream;
+import de.erichseifert.vectorgraphics2d.util.PageSize;
+
+/**
+ * Represents a {@code Document} in the Encapsulated PostScript®
+ * (EPS) format.
+ */
+class EPSDocument extends SizedDocument {
+ /** Constant to convert values from millimeters to PostScript® units
+ (1/72th inch). */
+ private static final double UNITS_PER_MM = 72.0 / 25.4;
+ private static final String CHARSET = "ISO-8859-1";
+ private static final String EOL = "\n";
+ private static final int MAX_LINE_WIDTH = 255;
+ private static final Pattern ELEMENT_SEPARATION_PATTERN = Pattern.compile("(.{1," + MAX_LINE_WIDTH + "})(\\s+|$)");
+
+ /** Mapping of stroke endcap values from Java to PostScript®. */
+ private static final Map STROKE_ENDCAPS = DataUtils.map(
+ new Integer[] { BasicStroke.CAP_BUTT, BasicStroke.CAP_ROUND, BasicStroke.CAP_SQUARE },
+ new Integer[] { 0, 1, 2 }
+ );
+
+ /** Mapping of line join values for path drawing from Java to
+ PostScript®. */
+ private static final Map STROKE_LINEJOIN = DataUtils.map(
+ new Integer[] { BasicStroke.JOIN_MITER, BasicStroke.JOIN_ROUND, BasicStroke.JOIN_BEVEL },
+ new Integer[] { 0, 1, 2 }
+ );
+
+ private static final String FONT_LATIN1_SUFFIX = "Lat";
+
+ private final List elements;
+
+ public EPSDocument(CommandSequence commands, PageSize pageSize) {
+ super(pageSize, true);
+ elements = new LinkedList<>();
+ addHeader();
+ for (Command command : commands) {
+ handle(command);
+ }
+ }
+
+ private void addHeader() {
+ double x=getPageSize().getX()*UNITS_PER_MM,
+ y=getPageSize().getY()*UNITS_PER_MM,
+ width=getPageSize().getWidth()*UNITS_PER_MM,
+ height=getPageSize().getHeight()*UNITS_PER_MM;
+ elements.addAll(Arrays.asList(
+ "%!PS-Adobe-3.0 EPSF-3.0",
+ "%%BoundingBox: " + ((int) Math.floor(x)) + " " + ((int) Math.floor(y)) + " " + ((int) Math.ceil(x + width)) + " " + ((int) Math.ceil(y + height)),
+ "%%HiResBoundingBox: " + x + " " + y + " " + (x + width) + " " + (y + height),
+ "%%LanguageLevel: 3",
+ "%%Pages: 1",
+ "%%EndComments",
+ "%%Page: 1 1",
+ "/M /moveto load def",
+ "/L /lineto load def",
+ "/C /curveto load def",
+ "/Z /closepath load def",
+ "/RL /rlineto load def",
+ "/rgb /setrgbcolor load def",
+ "/cmyk /setcmykcolor load def",
+ "/rect { /height exch def /width exch def /y exch def /x exch def x y M width 0 RL 0 height RL width neg 0 RL } bind def",
+ "/ellipse { /endangle exch def /startangle exch def /ry exch def /rx exch def /y exch def /x exch def /savematrix matrix currentmatrix def x y translate rx ry scale 0 0 1 startangle endangle arcn savematrix setmatrix } bind def",
+ "/imgdict { /datastream exch def /hasdata exch def /decodeScale exch def /bits exch def /bands exch def /imgheight exch def /imgwidth exch def << /ImageType 1 /Width imgwidth /Height imgheight /BitsPerComponent bits /Decode [bands {0 decodeScale} repeat] /ImageMatrix [imgwidth 0 0 imgheight 0 0] hasdata { /DataSource datastream } if >> } bind def",
+ "/latinize { /fontName exch def /fontNameNew exch def fontName findfont 0 dict copy begin /Encoding ISOLatin1Encoding def fontNameNew /FontName def currentdict end dup /FID undef fontNameNew exch definefont pop } bind def",
+ getOutput(GraphicsState.DEFAULT_FONT),
+ "gsave",
+ "clipsave",
+ "/DeviceRGB setcolorspace",
+ "0 " + height + " translate",
+ UNITS_PER_MM + " " + (-UNITS_PER_MM) + " scale",
+ "/basematrix matrix currentmatrix def"
+ ));
+ }
+
+ public void writeTo(OutputStream out) throws IOException {
+ OutputStreamWriter o = new OutputStreamWriter(out, CHARSET);
+ for (String element : elements) {
+ if (element == null) {
+ continue;
+ }
+
+ // Write current element in lines of 255 bytes (excluding line terminators)
+ // Numbers must not be separated by line breaks or errors will occur
+ // TODO: Integrate functionality into LineWrapOutputStream
+ Matcher chunkMatcher = ELEMENT_SEPARATION_PATTERN.matcher(element);
+
+ boolean chunkFound = false;
+ while (chunkMatcher.find()) {
+ chunkFound = true;
+ String chunk = chunkMatcher.group();
+ o.write(chunk, 0, chunk.length());
+ o.append(EOL);
+ }
+ if (!chunkFound) {
+ // TODO: Exception, if no whitespace can be found in the chunk
+ System.err.println("Unable to divide eps element into lines: " + element);
+ }
+ }
+ o.append("%%EOF");
+ o.flush();
+ }
+
+ public void handle(Command command) {
+ if (command instanceof SetClipCommand) {
+ SetClipCommand c = (SetClipCommand) command;
+ Shape clip = c.getValue();
+ elements.add("cliprestore");
+ if (clip != null) {
+ elements.add(getOutput(clip) + " clip");
+ }
+ } else if (command instanceof SetColorCommand) {
+ SetColorCommand c = (SetColorCommand) command;
+ elements.add(getOutput(c.getValue()));
+ } else if (command instanceof SetCompositeCommand) {
+ SetCompositeCommand c = (SetCompositeCommand) command;
+ // TODO Implement composite rendering for EPS
+ elements.add("% composite not yet implemented: " + c.getValue());
+ } else if (command instanceof SetFontCommand) {
+ SetFontCommand c = (SetFontCommand) command;
+ elements.add(getOutput(c.getValue()));
+ } else if (command instanceof SetPaintCommand) {
+ SetPaintCommand c = (SetPaintCommand) command;
+ // TODO Implement paint rendering for EPS
+ elements.add("% paint not yet implemented: " + c.getValue());
+ } else if (command instanceof SetStrokeCommand) {
+ SetStrokeCommand c = (SetStrokeCommand) command;
+ elements.add(getOutput(c.getValue()));
+ } else if (command instanceof SetTransformCommand) {
+ SetTransformCommand c = (SetTransformCommand) command;
+ StringBuilder e = new StringBuilder();
+ double[] matrix = new double[6];
+ c.getValue().getMatrix(matrix);
+ e.append("basematrix setmatrix [")
+ .append(DataUtils.join(" ", matrix)).append("] concat");
+ elements.add(e.toString());
+ } else if (command instanceof RotateCommand) {
+ RotateCommand c = (RotateCommand) command;
+ StringBuilder e = new StringBuilder();
+ double x = c.getCenterX();
+ double y = c.getCenterY();
+ boolean translated = x != 0.0 || y != 0.0;
+ if (translated) {
+ e.append(x).append(" ").append(y).append(" translate ");
+ }
+ e.append(Math.toDegrees(c.getTheta())).append(" rotate");
+ if (translated) {
+ e.append(" ");
+ e.append(-x).append(" ").append(-y).append(" translate");
+ }
+ elements.add(e.toString());
+ } else if (command instanceof ScaleCommand) {
+ ScaleCommand c = (ScaleCommand) command;
+ elements.add(DataUtils.format(c.getScaleX()) + " " + DataUtils.format(c.getScaleY()) + " scale");
+ } else if (command instanceof ShearCommand) {
+ ShearCommand c = (ShearCommand) command;
+ elements.add("[1 " + DataUtils.format(c.getShearY()) + " " + DataUtils.format(c.getShearX()) + " 1 0 0] concat");
+ } else if (command instanceof TransformCommand) {
+ TransformCommand c = (TransformCommand) command;
+ StringBuilder e = new StringBuilder();
+ double[] matrix = new double[6];
+ c.getValue().getMatrix(matrix);
+ e.append("[").append(DataUtils.join(" ", matrix))
+ .append("] concat");
+ elements.add(e.toString());
+ } else if (command instanceof TranslateCommand) {
+ TranslateCommand c = (TranslateCommand) command;
+ elements.add(String.valueOf(c.getDeltaX()) + " " + c.getDeltaY() + " translate");
+ } else if (command instanceof DrawImageCommand) {
+ DrawImageCommand c = (DrawImageCommand) command;
+ String e = getOutput(c.getValue(),
+ c.getImageWidth(), c.getImageHeight(),
+ c.getX(), c.getY(), c.getWidth(), c.getHeight());
+ elements.add(e);
+ } else if (command instanceof DrawShapeCommand) {
+ DrawShapeCommand c = (DrawShapeCommand) command;
+ elements.add(getOutput(c.getValue()) + " stroke");
+ } else if (command instanceof DrawStringCommand) {
+ DrawStringCommand c = (DrawStringCommand) command;
+ elements.add(getOutput(c.getValue(), c.getX(), c.getY()));
+ } else if (command instanceof FillShapeCommand) {
+ FillShapeCommand c = (FillShapeCommand) command;
+ String fillMethod = " fill";
+ Shape shape = c.getValue();
+ if (shape instanceof Path2D && ((Path2D) shape).getWindingRule() == Path2D.WIND_EVEN_ODD) {
+ fillMethod = " eofill";
+ }
+ elements.add(getOutput(c.getValue()) + fillMethod);
+ } else if (command instanceof CreateCommand) {
+ elements.add("gsave");
+ } else if (command instanceof DisposeCommand) {
+ elements.add("grestore");
+ }
+ }
+
+ private static String getOutput(Color color) {
+ // TODO Handle transparency
+ if (color.getColorSpace().getType() == ColorSpace.TYPE_CMYK) {
+ float[] cmyk = color.getComponents(null);
+ return String.format((Locale) null, "%f %f %f %f cmyk",
+ cmyk[0], cmyk[1], cmyk[2], cmyk[3]);
+ } else {
+ return String.format((Locale) null, "%f %f %f rgb",
+ color.getRed()/255f, color.getGreen()/255f, color.getBlue()/255f);
+ }
+ }
+
+ private static String getOutput(Shape s) {
+ StringBuilder out = new StringBuilder();
+ out.append("newpath ");
+ if (s instanceof Line2D) {
+ Line2D l = (Line2D) s;
+ out.append(l.getX1()).append(" ").append(l.getY1()).append(" M ")
+ .append(l.getX2()).append(" ").append(l.getY2()).append(" L");
+ } else if (s instanceof Rectangle2D) {
+ Rectangle2D r = (Rectangle2D) s;
+ out.append(r.getX()).append(" ").append(r.getY()).append(" ")
+ .append(r.getWidth()).append(" ").append(r.getHeight())
+ .append(" rect Z");
+ } else if (s instanceof Ellipse2D) {
+ Ellipse2D e = (Ellipse2D) s;
+ double x = e.getX() + e.getWidth()/2.0;
+ double y = e.getY() + e.getHeight()/2.0;
+ double rx = e.getWidth()/2.0;
+ double ry = e.getHeight()/2.0;
+ out.append(x).append(" ").append(y).append(" ")
+ .append(rx).append(" ").append(ry).append(" ")
+ .append(360.0).append(" ").append(0.0)
+ .append(" ellipse Z");
+ } else if (s instanceof Arc2D) {
+ Arc2D e = (Arc2D) s;
+ double x = (e.getX() + e.getWidth()/2.0);
+ double y = (e.getY() + e.getHeight()/2.0);
+ double rx = e.getWidth()/2.0;
+ double ry = e.getHeight()/2.0;
+ double startAngle = -e.getAngleStart();
+ double endAngle = -(e.getAngleStart() + e.getAngleExtent());
+ out.append(x).append(" ").append(y).append(" ")
+ .append(rx).append(" ").append(ry).append(" ")
+ .append(startAngle).append(" ").append(endAngle)
+ .append(" ellipse");
+ if (e.getArcType() == Arc2D.CHORD) {
+ out.append(" Z");
+ } else if (e.getArcType() == Arc2D.PIE) {
+ out.append(" ").append(x).append(" ").append(y).append(" L Z");
+ }
+ } else {
+ PathIterator segments = s.getPathIterator(null);
+ double[] coordsCur = new double[6];
+ double[] pointPrev = new double[2];
+ for (int i = 0; !segments.isDone(); i++, segments.next()) {
+ if (i > 0) {
+ out.append(" ");
+ }
+ int segmentType = segments.currentSegment(coordsCur);
+ switch (segmentType) {
+ case PathIterator.SEG_MOVETO:
+ out.append(coordsCur[0]).append(" ").append(coordsCur[1])
+ .append(" M");
+ pointPrev[0] = coordsCur[0];
+ pointPrev[1] = coordsCur[1];
+ break;
+ case PathIterator.SEG_LINETO:
+ out.append(coordsCur[0]).append(" ").append(coordsCur[1])
+ .append(" L");
+ pointPrev[0] = coordsCur[0];
+ pointPrev[1] = coordsCur[1];
+ break;
+ case PathIterator.SEG_CUBICTO:
+ out.append(coordsCur[0]).append(" ").append(coordsCur[1])
+ .append(" ").append(coordsCur[2]).append(" ")
+ .append(coordsCur[3]).append(" ").append(coordsCur[4])
+ .append(" ").append(coordsCur[5]).append(" C");
+ pointPrev[0] = coordsCur[4];
+ pointPrev[1] = coordsCur[5];
+ break;
+ case PathIterator.SEG_QUADTO:
+ double x1 = pointPrev[0] + 2.0/3.0*(coordsCur[0] - pointPrev[0]);
+ double y1 = pointPrev[1] + 2.0/3.0*(coordsCur[1] - pointPrev[1]);
+ double x2 = coordsCur[0] + 1.0/3.0*(coordsCur[2] - coordsCur[0]);
+ double y2 = coordsCur[1] + 1.0/3.0*(coordsCur[3] - coordsCur[1]);
+ double x3 = coordsCur[2];
+ double y3 = coordsCur[3];
+ out.append(x1).append(" ").append(y1).append(" ")
+ .append(x2).append(" ").append(y2).append(" ")
+ .append(x3).append(" ").append(y3).append(" C");
+ pointPrev[0] = x3;
+ pointPrev[1] = y3;
+ break;
+ case PathIterator.SEG_CLOSE:
+ out.append("Z");
+ break;
+ default:
+ throw new IllegalStateException("Unknown path operation.");
+ }
+ }
+ }
+ return out.toString();
+ }
+
+ private static String getOutput(Image image, int imageWidth, int imageHeight,
+ double x, double y, double width, double height) {
+ StringBuilder out = new StringBuilder();
+
+ BufferedImage bufferedImage = GraphicsUtils.toBufferedImage(image);
+ int bands = bufferedImage.getSampleModel().getNumBands();
+ int bitsPerSample = DataUtils.max(bufferedImage.getSampleModel().getSampleSize());
+ bitsPerSample = (int) (Math.ceil(bitsPerSample/8.0)*8.0);
+ if (bands > 3) {
+ bands = 3;
+ }
+
+ out.append("gsave").append(EOL);
+ if (x != 0.0 || y != 0.0) {
+ out.append(x).append(" ").append(y).append(" translate").append(EOL);
+ }
+ if (width != 1.0 || height != 1.0) {
+ out.append(width).append(" ").append(height).append(" scale").append(EOL);
+ }
+
+ int decodeScale = 1;
+ if (bufferedImage.getColorModel().hasAlpha()) {
+ // TODO Use different InterleaveType (2 or 3) for more efficient compression
+ out.append("<< /ImageType 3 /InterleaveType 1 ")
+ .append("/MaskDict ")
+ .append(imageWidth).append(" ").append(imageHeight).append(" ")
+ .append(1).append(" ").append(bitsPerSample).append(" ").append(decodeScale).append(" ")
+ .append(false).append(" ").append(0).append(" imgdict ")
+ .append("/DataDict ")
+ .append(imageWidth).append(" ").append(imageHeight).append(" ")
+ .append(bands).append(" ").append(bitsPerSample).append(" ").append(decodeScale).append(" ")
+ .append(true).append(" currentfile /ASCII85Decode filter ")
+ .append("<< /BitsPerComponent ").append(bitsPerSample).append(" >> ")
+ .append("/FlateDecode filter ")
+ .append("imgdict ")
+ .append(">> image").append(EOL);
+
+ // Convert alpha values to binary mask
+ // FIXME Do alpha conversion in a preprocessing step on commands
+ bufferedImage = new AlphaToMaskOp(true).filter(bufferedImage, null);
+ output(bufferedImage, out);
+ } else {
+ if (bands == 1) {
+ out.append("/DeviceGray setcolorspace").append(EOL);
+ }
+ if (bufferedImage.getType() == BufferedImage.TYPE_BYTE_BINARY) {
+ decodeScale = 255;
+ }
+ out.append(imageWidth).append(" ").append(imageHeight).append(" ")
+ .append(bands).append(" ").append(bitsPerSample).append(" ").append(decodeScale).append(" ")
+ .append(true).append(" currentfile /ASCII85Decode filter ")
+ .append("<< /BitsPerComponent ").append(bitsPerSample).append(" >> ")
+ .append("/FlateDecode filter ")
+ .append("imgdict ")
+ .append("image").append(EOL);
+ output(bufferedImage, out);
+ }
+
+ out.append("grestore");
+ return out.toString();
+ }
+
+ private static void output(BufferedImage image, StringBuilder out) {
+ InputStream imageDataStream =
+ new ImageDataStream(image, Interleaving.SAMPLE);
+ ByteArrayOutputStream outBytes = new ByteArrayOutputStream();
+ OutputStream compressionStream = new FlateEncodeStream(
+ new ASCII85EncodeStream(
+ new LineWrapOutputStream(outBytes, 80)));
+ try {
+ DataUtils.transfer(imageDataStream, compressionStream, 1024);
+ compressionStream.close();
+ String compressed = outBytes.toString(CHARSET);
+ out.append(compressed).append(EOL);
+ } catch (IOException e) {
+ // TODO Handle exception
+ e.printStackTrace();
+ }
+ }
+
+ private static String getOutput(String str, double x, double y) {
+
+ return "gsave 1 -1 scale " + x + " " + -y + " M " + getOutput(str) + " show " + "grestore";
+ }
+
+ private static StringBuilder getOutput(String str) {
+ StringBuilder out = new StringBuilder();
+
+ // Escape text
+ str = str.replaceAll("\\\\", "\\\\\\\\")
+ .replaceAll("\t", "\\\\t")
+ .replaceAll("\b", "\\\\b")
+ .replaceAll("\f", "\\\\f")
+ .replaceAll("\\(", "\\\\(")
+ .replaceAll("\\)", "\\\\)")
+ .replaceAll("[\r\n]", "");
+
+ out.append("(").append(str).append(")");
+
+ return out;
+ }
+
+ private static String getOutput(Stroke s) {
+ StringBuilder out = new StringBuilder();
+ if (s instanceof BasicStroke) {
+ BasicStroke bs = (BasicStroke) s;
+ out.append(bs.getLineWidth()).append(" setlinewidth ")
+ .append(STROKE_LINEJOIN.get(bs.getLineJoin())).append(" setlinejoin ")
+ .append(STROKE_ENDCAPS.get(bs.getEndCap())).append(" setlinecap ")
+ .append("[").append(DataUtils.join(" ", bs.getDashArray())).append("] ")
+ .append(bs.getDashPhase()).append(" setdash");
+ } else {
+ out.append("% Custom strokes aren't supported at the moment");
+ }
+ return out.toString();
+ }
+
+ private static String getOutput(Font font) {
+ StringBuilder out = new StringBuilder();
+ font = GraphicsUtils.getPhysicalFont(font);
+ String fontName = font.getPSName();
+
+ // Convert font to ISO-8859-1 encoding
+ String fontNameLatin1 = fontName + FONT_LATIN1_SUFFIX;
+ out.append("/").append(fontNameLatin1).append(" ")
+ .append("/").append(font.getPSName()).append(" latinize ");
+
+ // Use encoded font
+ out.append("/").append(fontNameLatin1).append(" ")
+ .append(font.getSize2D()).append(" selectfont");
+
+ return out.toString();
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/eps/EPSProcessor.java b/Java/src/de/erichseifert/vectorgraphics2d/eps/EPSProcessor.java
new file mode 100644
index 00000000..9653296b
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/eps/EPSProcessor.java
@@ -0,0 +1,48 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.eps;
+
+import de.erichseifert.vectorgraphics2d.Document;
+import de.erichseifert.vectorgraphics2d.Processor;
+import de.erichseifert.vectorgraphics2d.intermediate.CommandSequence;
+import de.erichseifert.vectorgraphics2d.intermediate.filters.FillPaintedShapeAsImageFilter;
+import de.erichseifert.vectorgraphics2d.util.PageSize;
+
+/**
+ * {@code Processor} implementation that translates {@link CommandSequence}s to
+ * a {@code Document} in the Encapsulated PostScript® (EPS) format.
+ */
+public class EPSProcessor implements Processor {
+ /**
+ * Initializes an {@code EPSProcessor}.
+ */
+ public EPSProcessor() {}
+
+ @Override
+ public Document getDocument(CommandSequence commands, PageSize pageSize) {
+ // TODO Apply rotate(theta,x,y) => translate-rotate-translate filter
+ // TODO Apply image transparency => image mask filter
+ // TODO Apply optimization filter
+ FillPaintedShapeAsImageFilter paintedShapeAsImageFilter = new FillPaintedShapeAsImageFilter(commands);
+ return new EPSDocument(paintedShapeAsImageFilter, pageSize);
+ }
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/eps/package-info.java b/Java/src/de/erichseifert/vectorgraphics2d/eps/package-info.java
new file mode 100644
index 00000000..7fb1c10c
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/eps/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+/**
+ * Implementation of a processor to convert VectorGraphics2D intermediate
+ * language commands to Encapsulated PostScript® (EPS).
+ */
+package de.erichseifert.vectorgraphics2d.eps;
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/CommandSequence.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/CommandSequence.java
new file mode 100644
index 00000000..bf740fec
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/CommandSequence.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate;
+
+import de.erichseifert.vectorgraphics2d.intermediate.commands.Command;
+
+/**
+ * Represents a sequence of {@link Command} objects.
+ * The individual {@code Command}s can be retrieved through an {@code Iterator}.
+ */
+public interface CommandSequence extends Iterable> {
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/MutableCommandSequence.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/MutableCommandSequence.java
new file mode 100644
index 00000000..9321fa1d
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/MutableCommandSequence.java
@@ -0,0 +1,52 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import de.erichseifert.vectorgraphics2d.intermediate.commands.Command;
+
+/**
+ * Mutable implementation of {@code CommandSequence}.
+ * It is possible to add commands to this sequence.
+ */
+public class MutableCommandSequence implements CommandSequence {
+ private final List> commands;
+
+ /**
+ * Initializes a new {@code CommandSequence} object.
+ */
+ public MutableCommandSequence() {
+ this.commands = new LinkedList<>();
+ }
+
+ public void add(Command command) {
+ commands.add(command);
+ }
+
+ @Override
+ public Iterator> iterator() {
+ return commands.iterator();
+ }
+}
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/AffineTransformCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/AffineTransformCommand.java
new file mode 100644
index 00000000..8c647740
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/AffineTransformCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.geom.AffineTransform;
+
+public abstract class AffineTransformCommand extends StateCommand {
+ public AffineTransformCommand(AffineTransform transform) {
+ super(transform);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/Command.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/Command.java
new file mode 100644
index 00000000..c6437e5e
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/Command.java
@@ -0,0 +1,52 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.util.Locale;
+
+public abstract class Command {
+ private final T value;
+
+ public Command(T value) {
+ this.value = value;
+ }
+
+ public T getValue() {
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return String.format((Locale) null, "%s[value=%s]",
+ getClass().getName(), getValue());
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null || !getClass().equals(obj.getClass())) {
+ return false;
+ }
+ Command o = (Command) obj;
+ return value == o.value || value.equals(o.value);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/CreateCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/CreateCommand.java
new file mode 100644
index 00000000..bfb1c894
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/CreateCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import de.erichseifert.vectorgraphics2d.VectorGraphics2D;
+
+public class CreateCommand extends StateCommand {
+ public CreateCommand(VectorGraphics2D graphics) {
+ super(graphics);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DisposeCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DisposeCommand.java
new file mode 100644
index 00000000..72e2e51f
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DisposeCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import de.erichseifert.vectorgraphics2d.VectorGraphics2D;
+
+public class DisposeCommand extends StateCommand {
+ public DisposeCommand(VectorGraphics2D graphics) {
+ super(graphics);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawImageCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawImageCommand.java
new file mode 100644
index 00000000..bcc21962
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawImageCommand.java
@@ -0,0 +1,75 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Image;
+import java.util.Locale;
+
+public class DrawImageCommand extends Command {
+ private final int imageWidth;
+ private final int imageHeight;
+ private final double x;
+ private final double y;
+ private final double width;
+ private final double height;
+
+ public DrawImageCommand(Image image, int imageWidth, int imageHeight,
+ double x, double y, double width, double height) {
+ super(image);
+ this.imageWidth = imageWidth;
+ this.imageHeight = imageHeight;
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+
+ public int getImageWidth() {
+ return imageWidth;
+ }
+ public int getImageHeight() {
+ return imageHeight;
+ }
+
+ public double getX() {
+ return x;
+ }
+ public double getY() {
+ return y;
+ }
+ public double getWidth() {
+ return width;
+ }
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public String toString() {
+ return String.format((Locale) null,
+ "%s[value=%s, imageWidth=%d, imageHeight=%d, x=%f, y=%f, width=%f, height=%f]",
+ getClass().getName(), getValue(),
+ getImageWidth(), getImageHeight(),
+ getX(), getY(), getWidth(), getHeight());
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawShapeCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawShapeCommand.java
new file mode 100644
index 00000000..552f6c8f
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawShapeCommand.java
@@ -0,0 +1,33 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Shape;
+
+import de.erichseifert.vectorgraphics2d.util.GraphicsUtils;
+
+public class DrawShapeCommand extends Command {
+ public DrawShapeCommand(Shape shape) {
+ super(GraphicsUtils.clone(shape));
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawStringCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawStringCommand.java
new file mode 100644
index 00000000..969edca2
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/DrawStringCommand.java
@@ -0,0 +1,51 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.util.Locale;
+
+
+public class DrawStringCommand extends Command {
+ private final double x;
+ private final double y;
+
+ public DrawStringCommand(String string, double x, double y) {
+ super(string);
+ this.x = x;
+ this.y = y;
+ }
+
+ public double getX() {
+ return x;
+ }
+
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public String toString() {
+ return String.format((Locale) null, "%s[value=%s, x=%f, y=%f]",
+ getClass().getName(), getValue(), getX(), getY());
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/FillShapeCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/FillShapeCommand.java
new file mode 100644
index 00000000..e44c084a
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/FillShapeCommand.java
@@ -0,0 +1,33 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Shape;
+
+import de.erichseifert.vectorgraphics2d.util.GraphicsUtils;
+
+public class FillShapeCommand extends Command {
+ public FillShapeCommand(Shape shape) {
+ super(GraphicsUtils.clone(shape));
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/Group.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/Group.java
new file mode 100644
index 00000000..42b1e1d9
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/Group.java
@@ -0,0 +1,37 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class Group extends Command>> {
+ public Group() {
+ super(new LinkedList<>());
+ }
+
+ public void add(Command command) {
+ List> group = getValue();
+ group.add(command);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/RotateCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/RotateCommand.java
new file mode 100644
index 00000000..fe91c9f8
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/RotateCommand.java
@@ -0,0 +1,59 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.geom.AffineTransform;
+import java.util.Locale;
+
+public class RotateCommand extends AffineTransformCommand {
+ private final double theta;
+ private final double centerX;
+ private final double centerY;
+
+ public RotateCommand(double theta, double centerX, double centerY) {
+ super(AffineTransform.getRotateInstance(theta, centerX, centerY));
+ this.theta = theta;
+ this.centerX = centerX;
+ this.centerY = centerY;
+ }
+
+ public double getTheta() {
+ return theta;
+ }
+
+ public double getCenterX() {
+ return centerX;
+ }
+
+ public double getCenterY() {
+ return centerY;
+ }
+
+ @Override
+ public String toString() {
+ return String.format((Locale) null,
+ "%s[theta=%f, centerX=%f, centerY=%f, value=%s]",
+ getClass().getName(), getTheta(), getCenterX(), getCenterY(),
+ getValue());
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/ScaleCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/ScaleCommand.java
new file mode 100644
index 00000000..c88a31ca
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/ScaleCommand.java
@@ -0,0 +1,52 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.geom.AffineTransform;
+import java.util.Locale;
+
+public class ScaleCommand extends AffineTransformCommand {
+ private final double scaleX;
+ private final double scaleY;
+
+ public ScaleCommand(double scaleX, double scaleY) {
+ super(AffineTransform.getScaleInstance(scaleX, scaleY));
+ this.scaleX = scaleX;
+ this.scaleY = scaleY;
+ }
+
+ public double getScaleX() {
+ return scaleX;
+ }
+
+ public double getScaleY() {
+ return scaleY;
+ }
+
+ @Override
+ public String toString() {
+ return String.format((Locale) null,
+ "%s[scaleX=%f, scaleY=%f, value=%s]", getClass().getName(),
+ getScaleX(), getScaleY(), getValue());
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetBackgroundCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetBackgroundCommand.java
new file mode 100644
index 00000000..90188b09
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetBackgroundCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Color;
+
+public class SetBackgroundCommand extends StateCommand {
+ public SetBackgroundCommand(Color color) {
+ super(color);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetClipCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetClipCommand.java
new file mode 100644
index 00000000..5b63ce10
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetClipCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Shape;
+
+public class SetClipCommand extends StateCommand {
+ public SetClipCommand(Shape shape) {
+ super(shape);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetColorCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetColorCommand.java
new file mode 100644
index 00000000..997947f8
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetColorCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Color;
+
+public class SetColorCommand extends StateCommand {
+ public SetColorCommand(Color color) {
+ super(color);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetCompositeCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetCompositeCommand.java
new file mode 100644
index 00000000..89328cb2
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetCompositeCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Composite;
+
+public class SetCompositeCommand extends StateCommand {
+ public SetCompositeCommand(Composite composite) {
+ super(composite);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetFontCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetFontCommand.java
new file mode 100644
index 00000000..01d82d8f
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetFontCommand.java
@@ -0,0 +1,31 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.awt.Font;
+
+public class SetFontCommand extends StateCommand {
+ public SetFontCommand(Font font) {
+ super(font);
+ }
+}
+
diff --git a/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetHintCommand.java b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetHintCommand.java
new file mode 100644
index 00000000..d9c7f914
--- /dev/null
+++ b/Java/src/de/erichseifert/vectorgraphics2d/intermediate/commands/SetHintCommand.java
@@ -0,0 +1,45 @@
+/*
+ * VectorGraphics2D: Vector export for Java(R) Graphics2D
+ *
+ * (C) Copyright 2010-2019 Erich Seifert ,
+ * Michael Seifert
+ *
+ * This file is part of VectorGraphics2D.
+ *
+ * VectorGraphics2D is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * VectorGraphics2D is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with VectorGraphics2D. If not, see .
+ */
+package de.erichseifert.vectorgraphics2d.intermediate.commands;
+
+import java.util.Locale;
+
+public class SetHintCommand extends StateCommand
Jama.CholeskyDecomposition
+