Laboratoire ICAR » Plateforme TXM

ERROR_EXPORT_TXT = Error while exporting CAH result: 

LOG_COMPUTE_CAH = Computing CAH

RESULT_TYPE = Classification

RESULT_TYPE = Классификация

ERROR_EXPORT_TXT = Erreur durant l'export du résultat CAH : 

LOG_COMPUTE_CAH = Calcul de la CAH

RESULT_TYPE = Classification

package org.txm.ahc.core.messages;

import org.txm.utils.messages.Utf8NLS;

public class AHCCoreMessages extends Utf8NLS {

	static {

		Utf8NLS.initializeMessages(AHCCoreMessages.class);

	}

	public static String RESULT_TYPE;

	public static String ERROR_EXPORT_TXT;

	public static String LOG_COMPUTE_CAH;

}

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

//

// The TXM platform 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.

//

// The TXM platform 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 the TXM platform. If not, see

// http://www.gnu.org/licenses.

//

//

//

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$

//

package org.txm.ahc.core.functions;

import java.io.File;

import java.util.Arrays;

import org.rosuda.REngine.REXP;

import org.txm.ca.core.functions.CA;

import org.txm.ahc.core.messages.AHCCoreMessages;

import org.txm.ahc.core.preferences.AHCPreferences;

import org.txm.chartsengine.core.results.ChartResult;

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMParameters;

import org.txm.lexicaltable.core.functions.LexicalTable;

import org.txm.statsengine.r.core.RWorkspace;

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

import org.txm.utils.logger.Log;

/**

 * Agglomerative Hierarchical Clustering.

 * 

 * @author mdecorde

 * @author sjacquot

 *

 */

public class AHC extends ChartResult	{

	/**

	 * The R name prefix.

	 */

	protected static String prefixR = "FactoMineRAHC"; //$NON-NLS-1$

	/**

	 * Counter used in name suffix.

	 */

	protected static int ahcCounter = 1;

	/** The symbol. */

	String symbol = null;

	/** The CA symbol target. */

	String target;

	/**

	 * The coordinates of the clusters.

	 */

	protected double[][] clusterCoords = null;

	/**

	 * The numbers of the clusters.

	 */

	protected int[] clusterNumbers = null;

	/**

	 * The names of the cluster rows.

	 */

	protected String[] clusterRowNames = null;

	/**

	 * The ordered names of the cluster rows.

	 */

	protected String[] clusterOrderedRowNames = null;

	/**

	 * The cluster tree heights.

	 */

	protected double[] clusterHeights = null;

	/**

	 * The cluster tree merges.

	 */

	protected double[][] clusterMerges = null;

	/**

	 * The inertia gains.

	 */

	protected double[] inertiaGains = null;

	protected CA ca;

	protected LexicalTable table;

	/**

	 * The metric (euclidean, manhattan).

	 */

	@Parameter(key=AHCPreferences.METRIC)

	protected String metric;

	/**

	 * The method (METHODS <- c("average", "single", "complete", "ward", "weighted", "flexible")).

	 */

	@Parameter(key=AHCPreferences.METHOD)

	protected String method;

	/**

	 * The number of clusters.

	 */

	@Parameter(key=AHCPreferences.N_CLUSTERS)

	protected int numberOfClusters;

	/**

	 * To compute the columns or the rows.

	 */

	@Parameter(key=AHCPreferences.COLUMNS_COMPUTING)

	protected boolean columnsComputing;

	/**

	 * To display in 2D or 3D.

	 */

	@Parameter(key=AHCPreferences.RENDERING_2D)

	protected boolean rendering2D;

	/**

	 * Instantiates a new AHC.

	 *

	 * @param ca the ca

	 * @param col the col

	 * @param method the method

	 * @param metric the metric

	 * @param numberOfClusters the n cluster

	 * @param display2D the display mode

	 */

	public AHC(CA ca)	{

		super(ca);

		this.ca = ca;

	}

	@Override

	protected boolean _compute()	{

		Log.info("Computing CAH...");

		try {

			this.table = this.ca.getLexicalTable();

			this.target = this.ca.getSymbol();

			// reset the number of clusters to default

			if(this.hasParameterChanged(AHCPreferences.COLUMNS_COMPUTING))	{

				this.numberOfClusters = TXMPreferences.getInt(AHCPreferences.N_CLUSTERS, AHCPreferences.PREFERENCES_NODE);

			}

			String colOrLine = "columns"; //$NON-NLS-1$

			if (!this.columnsComputing)

				colOrLine ="rows"; //$NON-NLS-1$

			if (this.symbol == null)	{

				this.symbol = prefixR + (ahcCounter++);

			}

			RWorkspace rw = RWorkspace.getRWorkspaceInstance();

			rw.eval("library(FactoMineR)"); //$NON-NLS-1$

			rw.eval(this.symbol +" <- HCPC(" + this.target + //$NON-NLS-1$

					", cluster.CA=\"" + colOrLine + "\"" + //$NON-NLS-1$ //$NON-NLS-2$

					", nb.clust=" + this.numberOfClusters + //$NON-NLS-1$

					", metric=\"" + this.metric + "\"" + //$NON-NLS-1$ //$NON-NLS-2$

					", method=\"" + this.method + "\"" + //$NON-NLS-1$ //$NON-NLS-2$

					", graph=FALSE)"); //$NON-NLS-1$

		} catch(Exception e) {

			Log.printStackTrace(e);

			return false;

		}

		// Reset the cached data

		this.resetCache();

		this.dirty = false;

		return true;

	}

	public void setParameters(Boolean columns, String metric, Integer nCluster, String method) {

		if (columns != null) this.columnsComputing = columns;

		if (metric != null) this.metric = metric;

		if (nCluster != null) this.numberOfClusters = nCluster;

		if (method != null) this.method = method;

		dirty = true;

	}

	@Override

	public boolean loadParameters() {

		// nothing to do

		return true;

	}

	@Override

	public boolean saveParameters() {

		// nothing to do

		return true;

	}

	@Override

	public boolean canCompute() {

		return this.ca != null 

				&& Arrays.binarySearch(AHC.getMethods(), this.method) >= 0 

				&& Arrays.binarySearch(AHC.getMetrics(), this.metric) >= 0

				&& this.numberOfClusters >= 2;

	}

	@Override

	public boolean setParameters(TXMParameters parameters) {

		// TODO Auto-generated method stub

		System.err.println("AHC.setParameters(): not yet implemented.");

		return true;

	}

	/**

	 * Resets the cached data so the next getter calls will request the values from R.

	 */

	public void resetCache() {

		this.clusterCoords = null;

		this.clusterNumbers = null;

		this.clusterRowNames = null;

		this.clusterOrderedRowNames = null;

		this.clusterHeights = null;

		this.clusterMerges = null;

	}

	/**

	 * Gets the symbol.

	 *

	 * @return the symbol

	 */

	public String getSymbol() {

		return symbol;

	}

	/**

	 * Gets the methods.

	 *

	 * @return the methods

	 */

	public static String[] getMethods() {

		String[] methods = {"average", "single", "complete", "ward", "weighted", "flexible"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$

		return methods;

	}

	/**

	 * Gets the metrics.

	 *

	 * @return the metrics

	 */

	public static String[] getMetrics() {

		String[] metrics = {"euclidean", "manhattan"}; //$NON-NLS-1$ //$NON-NLS-2$

		return metrics;

	}

	/**

	 *

	 * @param outfile

	 * @param encoding

	 * @return

	 */

	//FIXME: extract to future exporter extension

	@Deprecated

	public boolean toTxt(File outfile, String encoding)	{

		boolean ret = true;

		acquireSemaphore();

		RWorkspace rw;

		try {

			rw = RWorkspace.getRWorkspaceInstance();

			rw.eval("sink(file=\"" + outfile.getAbsolutePath().replace("\\", "\\\\")+"\")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

			rw.eval("print("+symbol+"$call)"); //$NON-NLS-1$ //$NON-NLS-2$

			rw.eval("sink()"); //$NON-NLS-1$

		} catch (RWorkspaceException e) {

			// TODO Auto-generated catch block

			System.out.println(AHCCoreMessages.ERROR_EXPORT_TXT + e);

			org.txm.utils.logger.Log.printStackTrace(e);

			ret = false;

		} finally {

			releaseSemaphore();

		}

		return true;

	}

	//FIXME: extract to future exporter extension

	@Deprecated

	public boolean toTxt(File outfile, String encoding, String colsep, String txtsep) {

		return toTxt(outfile, encoding);

	}

	/**

	 * Gets the default method.

	 *

	 * @return the default method

	 */

	public static String getDefaultMethod() {

		return "ward"; //$NON-NLS-1$

	}

	/**

	 * Gets the default metric.

	 *

	 * @return the default metric

	 */

	public static String getDefaultMetric() {

		return "euclidean"; //$NON-NLS-1$

	}

	@Override

	public void clean() {

		// TODO Auto-generated method stub

	}

	/**

	 * Gets the clusters coordinates.

	 * @return the clusters coordinates

	 */

	public double[][] getClusterCoords() {

		if (this.clusterCoords == null) {

			try {

				// FIXME: check this code for the CAH 3D chart implementation

				RWorkspace rw = RWorkspace.getRWorkspaceInstance();

				for(int i = 0; i < 2; i++) { // 2 dimensions

					REXP sv = rw.extractItemFromListByName(symbol, "data.clust[,"+ (i + 1)+ "]"); //$NON-NLS-1$

					double[] coords = RWorkspace.toDouble(sv);

					for(int j = 0; j < coords.length; j++) {

						if(this.clusterCoords  == null)	{

							this.clusterCoords = new double[coords.length][2];

						}

						this.clusterCoords[j][i] = coords[j];

					}

				}

			}

			catch (Exception e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

		return this.clusterCoords;

	}

	/**

	 * Gets the clusters numbers.

	 * @return

	 */

	public int[] getClusterNumbers() {

		if (this.clusterNumbers == null) {

			try {

				RWorkspace rw = RWorkspace.getRWorkspaceInstance();

				// FIXME: not sorted version

				REXP sv = rw.extractItemFromListByName(symbol, "data$clust"); //$NON-NLS-1$

				// FIXME: sorted version

				//REXP sv = rw.extractItemFromListByName(symbol, "data$clust[c(" + symbol + "$call$t$tree$order)]"); //$NON-NLS-1$

				this.clusterNumbers = sv.asIntegers();

			}

			catch (Exception e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

		return this.clusterNumbers;

	}

	/**

	 * Gets the cluster row names.

	 * @return

	 */

	public String[] getClusterRowNames() {

		if (this.clusterRowNames == null) {

			try {

				RWorkspace rw = RWorkspace.getRWorkspaceInstance();

				// FIXME: old method, Save the row names in the R data frame

				//				rw.safeEval(symbol + "$rownames <- rownames(" + symbol + "$data)");

				//				REXP sv = rw.extractItemFromListByName(symbol, "rownames"); //$NON-NLS-1$

				REXP sv = rw.extractItemFromListByName(symbol, "call$t$tree$labels"); //$NON-NLS-1$

				this.clusterRowNames = sv.asStrings();

			}

			catch (Exception e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

		return this.clusterRowNames;

	}

	/**

	 * Gets the cluster orderer row names.

	 * @return

	 */

	public String[] getClusterOrderedRowNames() {

		if (this.clusterOrderedRowNames == null) {

			try {

				RWorkspace rw = RWorkspace.getRWorkspaceInstance();

				REXP sv = rw.extractItemFromListByName(symbol, "call$t$tree$labels[c(" + symbol + "$call$t$tree$order)]"); //$NON-NLS-1$

				this.clusterOrderedRowNames = sv.asStrings();

			}

			catch (Exception e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

		return this.clusterOrderedRowNames;

	}

	/**

	 * Gets the cluster tree heights.

	 * @return

	 */

	public double[] getClusterTreeHeights() {

		if (this.clusterHeights == null) {

			try {

				RWorkspace rw = RWorkspace.getRWorkspaceInstance();

				REXP sv = rw.extractItemFromListByName(symbol, "call$t$tree$height"); //$NON-NLS-1$

				this.clusterHeights = sv.asDoubles();

			}

			catch (Exception e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

		return this.clusterHeights;

	}

	/**

	 * Gets the inertia gains.

	 * @return

	 */

	// FIXME: for test purpose, this method is not used for the chart computing

	public double[] getInertiaGains() {

		if (this.inertiaGains == null) {

			try {

				RWorkspace rw = RWorkspace.getRWorkspaceInstance();

				REXP sv = rw.extractItemFromListByName(symbol, "call$t$inert.gain"); //$NON-NLS-1$

				// FIXME: tests

				//			REXP sv = rw.extractItemFromListByName(symbol, "call$t$within"); //$NON-NLS-1$

				this.inertiaGains = sv.asDoubles();

			}

			catch (Exception e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

		return this.inertiaGains;

	}

	/**

	 * Gets the cluster tree merges.

	 * @return

	 */

	public double[][] getClusterTreeMerges() {

		if (this.clusterMerges == null) {

			try {

				RWorkspace rw = RWorkspace.getRWorkspaceInstance();

				REXP sv = rw.extractItemFromListByName(symbol, "call$t$tree$merge"); //$NON-NLS-1$

				this.clusterMerges = sv.asDoubleMatrix();

			}

			catch (Exception e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

		return this.clusterMerges;

	}

	/**

	 * Sets the metric to use for computing.

	 * @param metric the metric to set

	 */

	public void setMetric(String metric) {

		this.metric = metric;

	}

	/**

	 * Sets the method to use for computing

	 * @param method the method to set

	 */

	public void setMethod(String method) {

		this.method = method;

	}

	/**

	 * Sets the computing to columns or rows and rest the number of clusters to default value.

	 * @param columnsComputing the columns to set

	 */

	public void setColumnsComputing(boolean columnsComputing) {

		this.columnsComputing = columnsComputing;

	}

	/**

	 * Sets the number of clusters to use for computing

	 * @param nClusters the nCluster to set

	 */

	public void setNumberOfClusters(int nClusters) {

		numberOfClusters = nClusters;

	}

	/**

	 * Checks if the computing mode is set as columns. If not, the computing mode is set as rows.

	 * @return  

	 */

	public boolean isColumnsComputing() {

		return columnsComputing;

	}

	/**

	 * Gets the maximum clusters available according to the current computing mode (columns or rows) and according to current source (<code>CA</code> or <code>LexicalTable</code>).

	 * The maximum numbers of available clusters is for now limited to 16 by this method due of a limitation of FactoMineR plot.HCPC().

	 * @return the maximum clusters available according to the current computing mode

	 */

	public int getMaxClustersCount()	{

		int maxClustersCount = -1;

		try {

			RWorkspace rw = RWorkspace.getRWorkspaceInstance();

			REXP sv = rw.eval("min(length(" + symbol + "$data$clust) - 1, 16)"); //$NON-NLS-1$ //$NON-NLS-2$

			maxClustersCount = sv.asInteger();

		} catch(Exception e) {

			System.out.println("Error: "+e.getLocalizedMessage());

			Log.printStackTrace(e);

		}

		// FIXME: FactoMineR plot.HCPC doesn't manage more than 16 clusters when tree.barplot=TRUE, therefore we can't plot a SVG with more than that, see ticket #836 then use the code below in ChartsEngine to compute

		// the real maximum available clusters count

		//		// CA

		//		if(this.source instanceof CA)	{

		//			if(this.columns == true)	{

		//				maxClustersCount = ((CA)this.source).getColumnsCount() - 1;

		//			}

		//			else	{

		//				maxClustersCount = ((CA)this.source).getRowsCount() - 1;

		//			}

		//		}

		//		// Lexical table

		//		else if(this.source instanceof LexicalTable)	{

		//			if(this.columns == true)	{

		//				maxClustersCount = ((LexicalTable)this.source).getColumnsCount() - 1;

		//			}

		//			else	{

		//				maxClustersCount = ((LexicalTable)this.source).getRowsCount() - 1;

		//			}

		//		}

		return maxClustersCount;

	}

	@Override

	public String[] getExportTXTExtensions() {

		return new String[]{"*.txt"};

	}

	/**

	 * Returns the number of clusters.

	 * @return the number of clusters

	 */

	public int getNumberOfClusters() {

		return numberOfClusters;

	}

	public CA getCA() {

		return ca;

	}

	public LexicalTable getLexicalTable() {

		return table;

	}

	@Override

	public String getName() {

		return getParent().getName();

	}

	@Override

	public String getSimpleName() {

		StringBuffer buffer = new StringBuffer();

		buffer.append(this.columnsComputing ? "cols" : "rows"); //$NON-NLS-1$

		buffer.append(this.method);

		buffer.append(this.metric);

		buffer.append(this.numberOfClusters);

		return this.getName();

	}

	@Override

	public String getDetails() {

		return this.getName();

	}

	/**

	 * Gets the 2D rendering state.

	 * If false, the rendering will be done in 3D.

	 * @return the rendering2D

	 */

	public boolean isRendering2D() {

		return rendering2D;

	}

	/**

	 * Sets the 2D rendering state.

	 * If set to false, the rendering will be done in 3D.

	 * @param rendering2d the rendering2D to set

	 */

	public void setRendering2D(boolean rendering2d) {

		rendering2D = rendering2d;

	}

}

<html>

<body>

<p>Classifcation using FactoMineR's CAH.</p>

</body>

</html>

package org.txm.ahc.core.chartsengine.jfreechart;

import org.jfree.chart.JFreeChart;

import org.txm.ahc.core.functions.AHC;

import org.txm.chartsengine.core.results.ChartResult;

import org.txm.chartsengine.jfreechart.core.JFCChartCreator;

/**

 * JFC CAH chart creator.

 * 

 * @author mdecorde

 * @author sjacquot

 * 

 * 

 */

public class JFCAHCChartCreator extends JFCChartCreator {

	@Override

	public JFreeChart createChart(ChartResult result) {

		System.err.println("JFCAHCChartCreator.createChart(): not yet implemented.");

		final AHC cah = (AHC) result;

		return null;

	}

	@Override

	// FIXME: to not load the chart creator, to remove when implemented 

	public Class getChartsEngineClass() {

		return null;

	}

	@Override

	public Class getResultDataClass() {

		return AHC.class;

	}

	// FIXME: old version with bar plot renderer

//	@Override

//	public JFreeChart createCAH2dChart(CAH cah) {

//

//

//		JFreeChart chart = null;

//

//		// Creating the data set from the result

//		DefaultCategoryDataset dataset = new DefaultCategoryDataset();

//		String category = "cluster ";

//

//

//

//		int[] clusterNumbers = cah.getClusterNumbers();

//		String[] rowNames = cah.getClusterRowNames();

//		String[] orderedRowNames = cah.getClusterOrderedRowNames();

//		double[] clusterHeights = cah.getClusterTreeHeights();

//		double[][] clusterMerges = cah.getClusterTreeMerges();

//		double[][] clusterCoords = cah.getClusterCoords();

//

//		double[] yValuesByOrderedRowNames = new double[rowNames.length];

//		double[] clusterNumbersValuesByOrderedRowNames = new double[rowNames.length];

//

//

//

//		// FIXME: Sort the cluster numbers in reverse order

////			Arrays.sort(clusterNumbers);

////			ArrayUtils.reverse(clusterNumbers);

////			System.out.println(Arrays.toString(clusterNumbers));

//

//

//		// FIXME: tests row names

//		//System.err.println("JFCChartsEngine.createCAH2dChart(): cluster row names: \t\t" + Arrays.toString(rowNames));

//

//		// FIXME: tests ordered row names

//		//System.err.println("JFCChartsEngine.createCAH2dChart(): cluster ordered row names: \t" + Arrays.toString(orderedRowNames));

//

//		// FIXME: tests, ordered cluster numbers

//		//System.err.println("JFCChartsEngine.createCAH2dChart(): cluster numbers: \t\t" + Arrays.toString(clusterNumbers));

//

//		// FIXME: tests, cluster tree merges

//		//System.err.println("JFCChartsEngine.createCAH2dChart(): cluster tree merges: \t\t" + Arrays.toString(clusterMerges));

//

//		// FIXME: tests, heights

////		System.err.println("JFCChartsEngine.createCAH2dChart(): cluster heights: \t\t" + Arrays.toString(clusterHeights));

//

//

//		// FIXME: tests

//		System.err.println("JFCChartsEngine.createCAH2dChart(): tests: \t\t" + Arrays.toString(cah.getInertiaGains()));

//

//

//

//		System.out.println("JFCChartsEngine.createCAH2dChart() cluster heights count: " + clusterHeights.length);

//		for(int i = 0; i < clusterHeights.length; i++) {

//			System.out.println("JFCChartsEngine.createCAH2dChart() cluster height: " + new DecimalFormat("0.00000000000000000").format(clusterHeights[i]));

//		}

//

////

////		String[] clusterUnorderedRowNames = cah.getClusterRowNames();

////		for(int i = 0; i < clusterUnorderedRowNames.length; i++) {

////			System.out.println("JFCChartsEngine.createCAH2dChart() unordered row names " + i + " : " + clusterUnorderedRowNames[i]);

////		}

//

//		// Parse the merge pairs

//		// A negative number in the FactoMineR tree merge table means a singleton

//		for (int i = 0 ; i < clusterMerges.length ; i++) {

//

//			// FIXME: debug

//			//for (int j = 0 ; j < clusterMerges.length ; j++) {

//				System.err.println("JFCChartsEngine.createCAH2dChart(): cluster tree merges: \t\t" + Arrays.toString(clusterMerges[i]));

//				System.err.println("JFCChartsEngine.createCAH2dChart(): row names: \t\t" + rowNames[(int) Math.abs(clusterMerges[i][0]) - 1] + " | " + rowNames[(int) Math.abs(clusterMerges[i][1]) - 1]);

//

//

//			//}

//

//			// Leaves pair

//			if(clusterMerges[i][0] < 0)	{

//

//				//System.err.print("JFCChartsEngine.createCAH2dChart(): merging: " + rowNames[(int) Math.abs(clusterMerge[i][0]) - 1]);

//

//				// Put the height in the ordered by names values table

//				for(int j = 0; j < orderedRowNames.length; j++) {

//					if(orderedRowNames[j].equals(rowNames[(int) Math.abs(clusterMerges[i][0]) - 1]))	{

//						yValuesByOrderedRowNames[j] = clusterHeights[i];

//						//clusterNumbersValuesByOrderedRowNames[j] = clusterNumbers[(int) Math.abs(clusterMerge[i][0]) - 1];

//					}

//				}

//

//			}

//			// Non-singleton

////				else	{

////					//System.err.print("JFCChartsEngine.createCAH2dChart(): merging aggregation: " +  clusterMerge[i][0]);

////				}

//

//			// Leaves pair

//			if(clusterMerges[i][1] < 0)	{

//				//System.err.print(" with: " + rowNames[(int) Math.abs(clusterMerge[i][1]) - 1]);

//

//				// Put the height in the ordered by names values table

//				for(int j = 0; j < orderedRowNames.length; j++) {

//					if(orderedRowNames[j].equals(rowNames[(int) Math.abs(clusterMerges[i][1]) - 1]))	{

//						yValuesByOrderedRowNames[j] = clusterHeights[i];

//						//clusterNumbersValuesByOrderedRowNames[j] = clusterNumbers[(int) Math.abs(clusterMerge[i][1]) - 1];

//					}

//

//				}

//

//			}

//			// Non-singleton

////				else	{

////					//System.err.print(" with aggregation: " + clusterMerge[i][1]);

////				}

//

//			//System.err.println(" and height: " + clusterHeights[i] + " as aggregation: " + (i + 1));

//

//		}

//

//

//		//

////		for (int i = 0 ; i <  cah.getClusterTreeMerges().length; i++) {

////			System.err.println("JFCChartsEngine.createCAH2dChart() merges : ");

////			for(int j = 0; j < cah.getClusterTreeMerges()[i].length; j++) {

////				System.err.print(" : " + cah.getClusterTreeMerges()[i][j]);

////			}

////		}

//

//

//

////		ArrayList<Double> middlePoints = cah.getClusterTreeMiddlePoints();

////

////		for (int i = 0 ; i <  middlePoints.size(); i++) {

////			System.err.println("JFCChartsEngine.createCAH2dChart() middle points X: " + middlePoints.get(i));

////		}

//

//

//

////		for (int i = 0 ; i < cah.getClusterCoords().length ; i++) {

////			for(int j = 0; j < cah.getClusterCoords()[i].length; j++) {

////				//System.err.println("JFCChartsEngine.createCAH2dChart(): " + cah.getClusterCoords()[i][j]);

////				dataset.setValue(cah.getClusterCoords()[i][j], category + clusterNumbers[i], rownames[i]);

////			}

////		}

//

//

//

//		// Create chart title

//		String title = "title";

//		String xAxisLabel = "Column";

//		if(!cah.isColumnsComputing())	{

//			xAxisLabel = "Row";

//		}

//

//

//

//		// Create the data set

//		// FIXME: bar plot test

////		for(int i = 0; i < yValuesByOrderedRowNames.length; i++) {

////			//dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbers[clusterNumbers.length - 1 - i], orderedRowNames[i]);

////

////

////			dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbers[yValuesByOrderedRowNames.length - 1 - i], orderedRowNames[i]);

////			//dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbers[i], orderedRowNames[i]);

////

////			//dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbersValuesByOrderedRowNames[i], orderedRowNames[i]);

////		}

////

////		// Create the chart

////        chart = this.createCategoryBarChart(dataset, title, xAxisLabel, "Height", false, false, false);

////        ((IItemSelectionRenderer) chart.getCategoryPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_CAH_2D);

////

////        // Draw tree

////        for(int j = 0; j < chart.getCategoryPlot().getDataset().getColumnCount() - 1; j++) {

////			//System.err.println("JFCChartsEngine.createCAH2dChart(): " + chart.getCategoryPlot().getDataset().getColumnKey(j));

////

////

////        	// Non-singleton pairs lines

////			if(yValuesByOrderedRowNames[j] == yValuesByOrderedRowNames[j + 1])	{

////				chart.getCategoryPlot().addAnnotation(new CategoryLineAnnotation(chart.getCategoryPlot().getDataset().getColumnKey(j), yValuesByOrderedRowNames[j],

////						chart.getCategoryPlot().getDataset().getColumnKey(j + 1), yValuesByOrderedRowNames[j + 1], Color.red, new BasicStroke(2.0f)));

////			}

////

////

////			//chart.getCategoryPlot().addAnnotation(new Cate

////

////

////

////		}

//

//

//

//		// Create the data set

//		// FIXME: step chart test

////		for(int i = 0; i < yValuesByOrderedRowNames.length - 1; i++) {

////			if(yValuesByOrderedRowNames[i] == yValuesByOrderedRowNames[i + 1])	{

////				dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbers[yValuesByOrderedRowNames.length - 1 - i], orderedRowNames[i]);

////			}

////		}

//////		dataset.addValue(0, "test", "truc 1");

//////		dataset.addValue(0.5, "test", "truc 1");

//////		dataset.addValue(0.9, "test", "truc 1");

////		// Create the chart

////        chart = this.createCategoryStepChart(dataset, title, xAxisLabel, "Height", false, false);

////        ((IItemSelectionRenderer) chart.getCategoryPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_CAH_2D);

//

//

//		// Create the data set

//		// FIXME: XY category bar chart test

//		XYSeriesCollection dataset2 = new XYSeriesCollection();

//

//		// Last tree level (leaves level)

//		XYSeries series = new XYSeries("leaves");

//		for(int i = 0; i < yValuesByOrderedRowNames.length - 1; i++) {

//			series.add(i, 0);

//			series.add(i, yValuesByOrderedRowNames[i]);

//			if(yValuesByOrderedRowNames[i] == yValuesByOrderedRowNames[i + 1])	{

//				series.add(i + 1, yValuesByOrderedRowNames[i]);

//				series.add(i + 1, 0);

//			}

//			else	{

//				series.add(i + 1, null);

//			}

//		}

//		dataset2.addSeries(series);

//

//

//		// Link singletons to non singleton

//		series = new XYSeries("singleton to non singleton links");

//		for(int i = clusterHeights.length; i >= 0; i--) {

//

//			// Skip non singletons case

//			if(i > 3 && yValuesByOrderedRowNames[i] == yValuesByOrderedRowNames[i - 1] && yValuesByOrderedRowNames[i - 2] == yValuesByOrderedRowNames[i - 3])	{

//				continue;

//			}

//

//			// Link singletons to non singleton

//			if(i > 1 && yValuesByOrderedRowNames[i] == yValuesByOrderedRowNames[i - 1] && yValuesByOrderedRowNames[i - 1] != yValuesByOrderedRowNames[i - 2]) {

//				series.add(i - 0.5, yValuesByOrderedRowNames[i - 2]);

//				series.add(i - 0.5, yValuesByOrderedRowNames[i]);

//				series.add(i - 0.5, null);

//				series.add(i - 2, yValuesByOrderedRowNames[i - 2]);

//			}

//		}

//		dataset2.addSeries(series);

//

//		// Link singletons to newly created pairs

//		series = new XYSeries("singleton to newly created pairs");

//		for(int i = clusterHeights.length; i >= 0; i--) {

//

//			// Skip non singletons case

//			if(i > 0 && yValuesByOrderedRowNames[i] == yValuesByOrderedRowNames[i - 1])	{

//				series.add(i, null);

//				continue;

//			}

//

//			// Link singletons to newly created pairs

//			if(i < clusterHeights.length - 1 && yValuesByOrderedRowNames[i] != yValuesByOrderedRowNames[i + 1]

//					&& yValuesByOrderedRowNames[i + 1] != yValuesByOrderedRowNames[i + 2]

//

////						&& i > 1 &&

//

//							) {

//

//				series.add(i, null);

//

//				series.add(i, yValuesByOrderedRowNames[i]);

//

//				series.add(i + 1.75, yValuesByOrderedRowNames[i]);

//				series.add(i + 1.75, yValuesByOrderedRowNames[i + 1]);

//

//

//				//series.add(i - 2, yValuesByOrderedRowNames[i - 2]);

//			}

//		}

//		dataset2.addSeries(series);

//

//

//

//		// Link singletons; test 2

////		series = new XYSeries("singleton links");

////		for(int i = 0; i <  clusterHeights.length - 2; i++) {

////			if(i > 0 && i < clusterHeights.length - 2 && yValuesByOrderedRowNames[i] != yValuesByOrderedRowNames[i + 1] && yValuesByOrderedRowNames[i] != yValuesByOrderedRowNames[i - 1]) {

////				series.add(i, yValuesByOrderedRowNames[i]);

////				series.add(i + 1.5, yValuesByOrderedRowNames[i]);

////				series.add(i + 1.5, yValuesByOrderedRowNames[i + 1]);

////				series.add(i + 1.5, null);

////			}

////		}

////		dataset2.addSeries(series);

//

//

////		// Other clusters

////		ArrayList<Double> otherClusters = new ArrayList<Double>();

////		//series = new XYSeries("other clusters");

////		for(int i = 0; i < clusterHeights.length; i++) {

////			// If not a leaf

////			boolean done = false;

////			for(int j = 0; j < clusterNumbersValuesByOrderedRowNames.length; j++) {

////				if(clusterHeights[i] == yValuesByOrderedRowNames[j])	{

////					done = true;

////					break;

////				}

////			}

////			if(done)	{

////				continue;

////			}

////			System.err.println("JFCChartsEngine.createCAH2dChart() other clusters: " + new DecimalFormat("0.0000000000000000").format(clusterHeights[i]));

////		}

////		//dataset2.addSeries(series);

//

//

//

////		dataset.addValue(0, "test", "truc 1");

////		dataset.addValue(0.5, "test", "truc 1");

////		dataset.addValue(0.9, "test", "truc 1");

//		// Create the chart

//        //chart = this.createXYBarChart(dataset2, title, xAxisLabel, "Height", false, false);

//        chart = ChartFactory.createXYLineChart(

//        		title,      // chart title

//        		xAxisLabel,                      // x axis label

//                "height",                      // y axis label

//                dataset2,                  // data

//                PlotOrientation.VERTICAL,

//                true,                     // include legend

//                true,                     // tooltips

//                false                     // urls

//            );

//

//

//

//

//        chart.getXYPlot().setRenderer(this.theme.createXYLineAndShapeRenderer(true, false));

//        ((IItemSelectionRenderer) chart.getXYPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_CAH_2D);

//

//

//        //chart.getXYPlot().addAnnotation(new XYLineAnnotation(0.5,  yValuesByOrderedRowNames[0], 0.5,  yValuesByOrderedRowNames[0] + 0.002));

//

//

//

//

//

//

//

//

//        //System.err.println("JFCChartsEngine.createCAH2dChart() " + chart.getCategoryPlot().getCategories().get(0));

//        //chart.getCategoryPlot().addAnnotation(new CategoryLineAnnotation("1970-12-31", .0002, "1965-12-31", .00005, Color.red, new BasicStroke(2.0f)));

//

//        // Custom range axis for ticks drawing options

//        //chart.getCategoryPlot().setRangeAxis(new ExtendedNumberAxis((NumberAxis) chart.getCategoryPlot().getRangeAxis(), false, true, 0, DatasetUtilities.findMaximumRangeValue(chart.getCategoryPlot().getDataset()).doubleValue()));

//

//

//

//		// Apply theme to the chart

//		this.theme.apply(chart);

//

//

//

//		// FIXME: test algo R

//		int dimens = 2;

//		int ax1 = 0;

//		int ax2 = 1;

//		double x1, y1, x2, y2, w1, w2;

//

//		double h1, h2; // FIXME: when using 3 dimensions

//

//

//		double[][] aa = new double[clusterMerges.length][4];

//		for(int i = 0; i < clusterMerges.length; i++) {

//			for(int j = 0; j < 4; j++) {

//				aa[i][j] = 0;

//			}

//		}

//

//

//		   //aa=matrix(ncol=4, nrow=nrow(merge))

//

//

//

//

//		// Decrement/increment the cluster merge value because the R algorithm uses 1 as first table index

//

//		for(int i = 0; i < clusterMerges.length; i++) {

//			if(clusterMerges[i][0] < 0)	{

//				clusterMerges[i][0]++;

//			}

//			else	{

//				clusterMerges[i][0]--;

//			}

//

//			if(clusterMerges[i][1] < 0)	{

//				clusterMerges[i][1]++;

//			}

//			else	{

//				clusterMerges[i][1]--;

//			}

//		}

//

//

//		for(int i = 0; i < clusterMerges.length; i++) {

//

////		    for(i in 1:nrow(merge)){

//			     // if(merge[i,1]<0){

//			// Singleton

//			if(clusterMerges[i][0] < 0)	{

//

//

//			        x1 = clusterCoords[(int) -clusterMerges[i][0]][ax1];

//			        y1 = clusterCoords[(int) -clusterMerges[i][0]][ax2];

//

//

//			        h1 = 0;

//			        w1 = 1;

//			      }

//			      else{

//			        x1 = aa[(int) clusterMerges[i][0]][0];

//			        y1 = aa[(int) clusterMerges[i][0]][1];

//			        w1 = aa[(int) clusterMerges[i][0]][3];

//			        h1 = aa[(int) clusterMerges[i][0]][2];

//			      }

//			// Singleton

//			if(clusterMerges[i][1] < 0)	{

//			      //if(merge[i,2]<0){

//			        x2 = clusterCoords[-(int) clusterMerges[i][1]][ax1];

//			        y2 = clusterCoords[-(int) clusterMerges[i][1]][ax2];

//			        h2 = 0;

//			        w2 = 1;

//			      }

//			      else{

//			        x2 = aa[(int) clusterMerges[i][1]][0];

//			        y2 = aa[(int) clusterMerges[i][1]][1];

//			        w2 = aa[(int) clusterMerges[i][1]][3];

//			        h2 = aa[(int) clusterMerges[i][1]][2];

//			      }

//			      aa[i][0] = (w1 * x1 + w2 * x2) / (w1 + w2);

//			      aa[i][1] = (w1 * y1 + w2 * y2) / (w1 + w2);

//

//			      //if(i<=nrow(merge)-t.level+1)

//			      if(i <= clusterMerges.length)	{

//			    	  clusterHeights[i] = 0;

//			      }

//

//			      aa[i][2] = clusterHeights[i];

//			      aa[i][3] = w1 + w2;

//

////			      if(i>(nrow(merge)-t.level+1)){

////			      if(i > clusterMerges[i][1]){ // FIXME: this test is strange

////			        if(dimens==3) s$points3d(rbind(c(x1,y1,h1),c(x1,y1,height[i]), c(x2,y2,height[i]),c(x2,y2,h2)), lty=1, type="o", pch="")

//			        if(dimens == 2)	{

//			        //	lines(c(x1,x2), c(y1,y2), lwd=(height[i]/max(height))*3)

//

//			        	//chart.getXYPlot().addAnnotation(new XYLineAnnotation(x1, y1, x2, y2));

//			        	// tests with steps lines

//			        	x1 *= 10;

//			        	x2 *= 10;

//			        	y1 /= 100;

//			        	y2 /= 100;

//

//			        	chart.getXYPlot().addAnnotation(new XYLineAnnotation(x1, y1, x1, y2));

//			        	chart.getXYPlot().addAnnotation(new XYLineAnnotation(x1, y2, x2, y2));

//			        	chart.getXYPlot().addAnnotation(new XYLineAnnotation(x2, y2, x2, y1));

//

//

//			        	// FIXME: labels tests

//			        	chart.getXYPlot().addAnnotation(new XYTextAnnotation(rowNames[(int) Math.abs(clusterMerges[i][0])], x1, y1));

//			        	chart.getXYPlot().addAnnotation(new XYTextAnnotation(rowNames[(int) Math.abs(clusterMerges[i][1])], x2, y1));

//

//

//

////			        	chart.getXYPlot().addAnnotation(new XYLineAnnotation(y2, x1, y1, x1));

//

//

//			        	//chart.getXYPlot().addAnnotation(new XYLineAnnotation(x2, y2, x2, y2));

//

//

//			        	System.err.println("JFCChartsEngine.createCAH2dChart(): draw line " + x1 + ", " + y1 + " | " + x2 + "," + y2);

//			        }

////			      }

//		//	    }

//

//

//		}

//

//

//		// FIXME: test symbol axis

//		//chart.getXYPlot().setDomainAxis(new SymbolAxis("test symbol axis", new String[]{"A", "b", "c"}));

//

//		// FIXME: for cluster boxes we may use XYBoxAnnotation()

//

//

//		//chart.getXYPlot().addAnnotation(new XYLineAnnotation(x1, y1, x2, y2));

//

//

//        return chart;

//

//	}

	// FIXME: new version with category step renderer

//	@Override

//	public JFreeChart createCAH2dChart(CAH cah) {

//

//

//			JFreeChart chart = null;

//

//			// Creating the data set from the result

//			DefaultCategoryDataset dataset = new DefaultCategoryDataset();

//			String category = "cluster ";

//

//

//

//			int[] clusterNumbers = cah.getClusterNumbers();

//			String[] rowNames = cah.getClusterRowNames();

//			String[] orderedRowNames = cah.getClusterOrderedRowNames();

//			double[] clusterHeights = cah.getClusterTreeHeights();

//			double[][] clusterMerge = cah.getClusterTreeMerges();

//

//

//			double[] yValuesByOrderedRowNames = new double[rowNames.length];

//			double[] clusterNumbersValuesByOrderedRowNames = new double[rowNames.length];

//

//

//

//			// FIXME: Sort the cluster numbers in reverse order

////			Arrays.sort(clusterNumbers);

////			ArrayUtils.reverse(clusterNumbers);

////			System.out.println(Arrays.toString(clusterNumbers));

//

//

//			// FIXME: tests row names

//			//System.err.println("JFCChartsEngine.createCAH2dChart(): cluster row names: \t\t" + Arrays.toString(rowNames));

//

//			// FIXME: tests ordered row names

//			//System.err.println("JFCChartsEngine.createCAH2dChart(): cluster ordered row names: \t" + Arrays.toString(orderedRowNames));

//

//			// FIXME: tests, ordered cluster numbers

//			//System.err.println("JFCChartsEngine.createCAH2dChart(): cluster number: \t\t" + Arrays.toString(clusterNumbers));

//

//

//

//			for (int i = 0 ; i < clusterMerge.length ; i++) {

//

//				// Singleton

//				if(clusterMerge[i][0] < 0)	{

//

//					//System.err.print("JFCChartsEngine.createCAH2dChart(): merging: " + rowNames[(int) Math.abs(clusterMerge[i][0]) - 1]);

//

//					// Put the height in the ordered by names values table

//					for(int j = 0; j < orderedRowNames.length; j++) {

//						if(orderedRowNames[j].equals(rowNames[(int) Math.abs(clusterMerge[i][0]) - 1]))	{

//							yValuesByOrderedRowNames[j] = clusterHeights[i];

//							//clusterNumbersValuesByOrderedRowNames[j] = clusterNumbers[(int) Math.abs(clusterMerge[i][0]) - 1];

//						}

//					}

//

//				}

//				// Non-singleton

//				else	{

//					//System.err.print("JFCChartsEngine.createCAH2dChart(): merging aggregation: " +  clusterMerge[i][0]);

//				}

//

//				// Singleton

//				if(clusterMerge[i][1] < 0)	{

//					//System.err.print(" with: " + rowNames[(int) Math.abs(clusterMerge[i][1]) - 1]);

//

//					// Put the height in the ordered by names values table

//					for(int j = 0; j < orderedRowNames.length; j++) {

//						if(orderedRowNames[j].equals(rowNames[(int) Math.abs(clusterMerge[i][1]) - 1]))	{

//							yValuesByOrderedRowNames[j] = clusterHeights[i];

//							//clusterNumbersValuesByOrderedRowNames[j] = clusterNumbers[(int) Math.abs(clusterMerge[i][1]) - 1];

//						}

//

//					}

//

//				}

//				// Non-singleton

//				else	{

//					//System.err.print(" with aggregation: " + clusterMerge[i][1]);

//				}

//

//				//System.err.println(" and height: " + clusterHeights[i] + " as aggregation: " + (i + 1));

//

//			}

//

//

//			// Create the data set

//

//			for(int i = 0; i < yValuesByOrderedRowNames.length; i++) {

//				//dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbers[clusterNumbers.length - 1 - i], orderedRowNames[i]);

//

//				dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbers[yValuesByOrderedRowNames.length - 1 - i], orderedRowNames[i]);

//				//dataset.setValue(yValuesByOrderedRowNames[i], category, orderedRowNames[i]);

//

//				//dataset.setValue(yValuesByOrderedRowNames[i], category + clusterNumbersValuesByOrderedRowNames[i], orderedRowNames[i]);

//			}

//

////

////			for (int i = 0 ; i <  cah.getClusterTreeMerges().length; i++) {

////				System.err.println("JFCChartsEngine.createCAH2dChart() merges : ");

////				for(int j = 0; j < cah.getClusterTreeMerges()[i].length; j++) {

////					System.err.print(" : " + cah.getClusterTreeMerges()[i][j]);

////				}

////			}

//

//

//

////			ArrayList<Double> middlePoints = cah.getClusterTreeMiddlePoints();

////

////			for (int i = 0 ; i <  middlePoints.size(); i++) {

////				System.err.println("JFCChartsEngine.createCAH2dChart() middle points X: " + middlePoints.get(i));

////			}

//

//

//

////			for (int i = 0 ; i < cah.getClusterCoords().length ; i++) {

////				for(int j = 0; j < cah.getClusterCoords()[i].length; j++) {

////					//System.err.println("JFCChartsEngine.createCAH2dChart(): " + cah.getClusterCoords()[i][j]);

////					dataset.setValue(cah.getClusterCoords()[i][j], category + clusterNumbers[i], rownames[i]);

////				}

////			}

//

//

//

//			// Create chart title

//			String title = "title";

//			String xAxisLabel = "Column";

//			if(!cah.isColumnsComputing())	{

//				xAxisLabel = "Row";

//			}

//

//

//			// Create the chart

//	        chart = this.createCategoryStepChart(dataset, title, xAxisLabel, "Height", false, false);

//

//

//	        ((IItemSelectionRenderer) chart.getCategoryPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_CAH_2D);

//

//

//	        // Draw tree

//	        chart.getCategoryPlot().addAnnotation(new CategoryLineAnnotation(chart.getCategoryPlot().getDataset().getColumnKey(0), 5.0,

//	        		chart.getCategoryPlot().getDataset().getColumnKey(1), 8.0, Color.red, new BasicStroke(2.0f)));

//

//	        // Custom range axis for ticks drawing options: cut the range to minimum and maximum values

//	        chart.getCategoryPlot().setRangeAxis(new ExtendedNumberAxis((NumberAxis) chart.getCategoryPlot().getRangeAxis(), false, true, 0, DatasetUtilities.findMaximumRangeValue(chart.getCategoryPlot().getDataset()).doubleValue()));

//

//

//		return chart;

//

//

//

//

//	}

}

package org.txm.ahc.core.chartsengine.r;

import java.io.File;

import org.txm.ahc.core.functions.AHC;

import org.txm.ahc.core.preferences.AHCPreferences;

import org.txm.chartsengine.core.results.ChartResult;

import org.txm.chartsengine.r.core.RChartCreator;

/**

 * R CAH chart creator.

 * 

 * @author mdecorde

 * @author sjacquot

 *

 */

public class RAHCChartCreator extends RChartCreator {