@Override public int print(Graphics g, PageFormat pf, int page) throws PrinterException { if (page > 0) { return NO_SUCH_PAGE; } int i = pf.getOrientation(); // get the size of the page double pageWidth = pf.getImageableWidth(); double pageHeight = pf.getImageableHeight(); double myWidth = this.getWidth(); // - borderWidth * 2; double myHeight = this.getHeight(); // - borderWidth * 2; double scaleX = pageWidth / myWidth; double scaleY = pageHeight / myHeight; double minScale = Math.min(scaleX, scaleY); Graphics2D g2d = (Graphics2D) g; g2d.translate(pf.getImageableX(), pf.getImageableY()); g2d.scale(minScale, minScale); drawPlot(g); return PAGE_EXISTS; }
/** * The printing interface. * * @param g the graphic context. * @param pf the page format. * @param page the page number. * @return PAGE_EXISTS if the page has to be printed. * @throws PrinterException if a printing error occurs. */ public int print(Graphics g, PageFormat pf, int page) throws PrinterException { int npages = 0; // This might be explained as follows: // 1 - The Java printing system normally works with an internal // resolution which is 72 dpi (probably inspired by Postscript). // 2 - To have a sufficient resolution, this is increased by 16 times, // by using the scale method of the graphic object associated to the // printer. This gives a 72 dpi * 16=1152 dpi resolution. // 3 - The 0.127 mm pitch used in FidoCadJ corresponds to a 200 dpi // resolution. Calculating 1152 dpi / 200 dpi gives the 5.76 constant double xscale = 1.0 / 16; // Set 1152 logical units for an inch double yscale = 1.0 / 16; // as the standard resolution is 72 double zoom = 5.76; // act in a 1152 dpi resolution as 1:1 Graphics2D g2d = (Graphics2D) g; // User (0,0) is typically outside the imageable area, so we must // translate by the X and Y values in the PageFormat to avoid clipping if (printMirror) { g2d.translate(pf.getImageableX() + pf.getImageableWidth(), pf.getImageableY()); g2d.scale(-xscale, yscale); } else { g2d.translate(pf.getImageableX(), pf.getImageableY()); g2d.scale(xscale, yscale); } int printerWidth = (int) pf.getImageableWidth() * 16; // Perform an adjustement if we need to fit the drawing to the page. if (printFitToPage) { MapCoordinates zoomm = DrawingSize.calculateZoomToFit( cc.dmp, (int) pf.getImageableWidth() * 16, (int) pf.getImageableHeight() * 16, false); zoom = zoomm.getXMagnitude(); } MapCoordinates m = new MapCoordinates(); m.setMagnitudes(zoom, zoom); PointG o = new PointG(0, 0); int imageWidth = DrawingSize.getImageSize(cc.dmp, zoom, false, o).width; npages = (int) Math.floor((imageWidth - 1) / (double) printerWidth); // Check if we need more than one page if (printerWidth < imageWidth) { g2d.translate(-(printerWidth * page), 0); } // Check if printing is finished. if (page > npages) { return NO_SUCH_PAGE; } // Now we perform our rendering cc.drawingAgent.draw(new Graphics2DSwing(g2d), m); /* tell the caller that this page is part of the printed document */ return PAGE_EXISTS; }
@Override public void run() { amIActive = true; String shapefile = null; String inputFieldsString = null; String[] fieldNames = null; double z; int numFields; int progress = 0; int lastProgress = 0; int row; int a, i, j; double[] fieldAverages; double[] fieldTotals; boolean standardizedPCA = false; int numberOfComponentsOutput = 0; if (args.length <= 0) { showFeedback("Plugin parameters have not been set."); return; } // read the input parameters inputFieldsString = args[0]; standardizedPCA = Boolean.parseBoolean(args[1]); if (args[2].toLowerCase().contains("not")) { // not specified numberOfComponentsOutput = 0; } else { numberOfComponentsOutput = Integer.parseInt(args[2]); } try { // deal with the input fields String[] inputs = inputFieldsString.split(";"); shapefile = inputs[0]; numFields = inputs.length - 1; fieldNames = new String[numFields]; System.arraycopy(inputs, 1, fieldNames, 0, numFields); // read the appropriate field from the dbf file into an array AttributeTable table = new AttributeTable(shapefile.replace(".shp", ".dbf")); int numRecs = table.getNumberOfRecords(); DBFField[] fields = table.getAllFields(); ArrayList<Integer> PCAFields = new ArrayList<>(); for (j = 0; j < fieldNames.length; j++) { for (i = 0; i < fields.length; i++) { if (fields[i].getName().equals(fieldNames[j]) && (fields[i].getDataType() == DBFField.DBFDataType.NUMERIC || fields[i].getDataType() == DBFField.DBFDataType.FLOAT)) { PCAFields.add(i); } } } if (numFields != PCAFields.size()) { showFeedback( "Not all of the specified database fields were found in the file or " + "a field of a non-numerical type was selected."); return; } double[][] fieldArray = new double[numRecs][numFields]; Object[] rec; for (i = 0; i < numRecs; i++) { rec = table.getRecord(i); for (j = 0; j < numFields; j++) { fieldArray[i][j] = (Double) (rec[PCAFields.get(j)]); } if (cancelOp) { cancelOperation(); return; } progress = (int) (100f * i / (numRecs - 1)); if (progress != lastProgress) { updateProgress("Reading data:", progress); } lastProgress = progress; } fieldAverages = new double[numFields]; fieldTotals = new double[numFields]; // Calculate the means for (row = 0; row < numRecs; row++) { for (i = 0; i < numFields; i++) { fieldTotals[i] += fieldArray[row][i]; } } for (i = 0; i < numFields; i++) { fieldAverages[i] = fieldTotals[i] / numRecs; } // Calculate the covariance matrix and total deviations double[] fieldTotalDeviation = new double[numFields]; double[][] covariances = new double[numFields][numFields]; double[][] correlationMatrix = new double[numFields][numFields]; for (row = 0; row < numRecs; row++) { for (i = 0; i < numFields; i++) { fieldTotalDeviation[i] += (fieldArray[row][i] - fieldAverages[i]) * (fieldArray[row][i] - fieldAverages[i]); for (a = 0; a < numFields; a++) { covariances[i][a] += (fieldArray[row][i] - fieldAverages[i]) * (fieldArray[row][a] - fieldAverages[a]); } } if (cancelOp) { cancelOperation(); return; } progress = (int) (100f * row / (numRecs - 1)); if (progress != lastProgress) { updateProgress("Calculating covariances:", progress); } lastProgress = progress; } for (i = 0; i < numFields; i++) { for (a = 0; a < numFields; a++) { correlationMatrix[i][a] = covariances[i][a] / (Math.sqrt(fieldTotalDeviation[i] * fieldTotalDeviation[a])); } } for (i = 0; i < numFields; i++) { for (a = 0; a < numFields; a++) { covariances[i][a] = covariances[i][a] / (numRecs - 1); } } // Calculate the eigenvalues and eigenvectors Matrix cov = null; if (!standardizedPCA) { cov = new Matrix(covariances); } else { cov = new Matrix(correlationMatrix); } EigenvalueDecomposition eigen = cov.eig(); double[] eigenvalues; Matrix eigenvectors; SortedSet<PrincipalComponent> principalComponents; eigenvalues = eigen.getRealEigenvalues(); eigenvectors = eigen.getV(); double[][] vecs = eigenvectors.getArray(); int numComponents = eigenvectors.getColumnDimension(); // same as num rows. principalComponents = new TreeSet<PrincipalComponent>(); for (i = 0; i < numComponents; i++) { double[] eigenvector = new double[numComponents]; for (j = 0; j < numComponents; j++) { eigenvector[j] = vecs[j][i]; } principalComponents.add(new PrincipalComponent(eigenvalues[i], eigenvector)); } double totalEigenvalue = 0; for (i = 0; i < numComponents; i++) { totalEigenvalue += eigenvalues[i]; } double[][] explainedVarianceArray = new double[numComponents][2]; // percent and cum. percent j = 0; for (PrincipalComponent pc : principalComponents) { explainedVarianceArray[j][0] = pc.eigenValue / totalEigenvalue * 100.0; if (j == 0) { explainedVarianceArray[j][1] = explainedVarianceArray[j][0]; } else { explainedVarianceArray[j][1] = explainedVarianceArray[j][0] + explainedVarianceArray[j - 1][1]; } j++; } DecimalFormat df1 = new DecimalFormat("0.00"); DecimalFormat df2 = new DecimalFormat("0.0000"); DecimalFormat df3 = new DecimalFormat("0.000000"); DecimalFormat df4 = new DecimalFormat("0.000"); String ret = "Principal Component Analysis Report:\n\n"; ret += "Component\tExplained Var.\tCum. %\tEigenvalue\tEigenvector\n"; j = 0; for (PrincipalComponent pc : principalComponents) { String explainedVariance = df1.format(explainedVarianceArray[j][0]); String explainedCumVariance = df1.format(explainedVarianceArray[j][1]); double[] eigenvector = pc.eigenVector.clone(); ret += (j + 1) + "\t" + explainedVariance + "\t" + explainedCumVariance + "\t" + df2.format(pc.eigenValue) + "\t"; String eigenvec = "["; for (i = 0; i < numComponents; i++) { if (i < numComponents - 1) { eigenvec += df3.format(eigenvector[i]) + ", "; } else { eigenvec += df3.format(eigenvector[i]); } } eigenvec += "]"; ret += eigenvec + "\n"; if (j < numberOfComponentsOutput) { DBFField field = new DBFField(); field = new DBFField(); field.setName("COMP" + (j + 1)); field.setDataType(DBFField.DBFDataType.NUMERIC); field.setFieldLength(10); field.setDecimalCount(4); table.addField(field); for (row = 0; row < numRecs; row++) { z = 0; for (i = 0; i < numFields; i++) { z += fieldArray[row][i] * eigenvector[i]; } Object[] recData = table.getRecord(row); recData[recData.length - 1] = new Double(z); table.updateRecord(row, recData); if (cancelOp) { cancelOperation(); return; } progress = (int) (100f * row / (numRecs - 1)); if (progress != lastProgress) { updateProgress("Outputing Component " + (j + 1) + ":", progress); } lastProgress = progress; } } j++; } // calculate the factor loadings. ret += "\nFactor Loadings:\n"; ret += "\t\tComponent\n\t"; for (i = 0; i < numComponents; i++) { ret += (i + 1) + "\t"; } ret += "\n"; double loading = 0; if (!standardizedPCA) { for (i = 0; i < numFields; i++) { ret += "field " + (i + 1) + "\t"; for (PrincipalComponent pc : principalComponents) { double[] eigenvector = pc.eigenVector.clone(); double ev = pc.eigenValue; loading = (eigenvector[i] * Math.sqrt(ev)) / Math.sqrt(covariances[i][i]); ret += df4.format(loading) + "\t"; } ret += "\n"; } } else { for (i = 0; i < numFields; i++) { ret += "field " + (i + 1) + "\t"; for (PrincipalComponent pc : principalComponents) { double[] eigenvector = pc.eigenVector.clone(); double ev = pc.eigenValue; loading = (eigenvector[i] * Math.sqrt(ev)); ret += df4.format(loading) + "\t"; } ret += "\n"; } } ret += "\n"; for (i = 0; i < numFields; i++) { ret += "field " + (i + 1) + "\t" + fieldNames[i] + "\n"; } returnData(ret); if (numberOfComponentsOutput > 0) { returnData(table.getFileName()); } ScreePlot plot = new ScreePlot(explainedVarianceArray); returnData(plot); } catch (OutOfMemoryError oe) { myHost.showFeedback("An out-of-memory error has occurred during operation."); } catch (Exception e) { myHost.showFeedback("An error has occurred during operation. See log file for details."); myHost.logException("Error in " + getDescriptiveName(), e); } finally { updateProgress("Progress: ", 0); // tells the main application that this process is completed. amIActive = false; myHost.pluginComplete(); } }