diff options
Diffstat (limited to 'src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot')
30 files changed, 5935 insertions, 0 deletions
diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AbstractScatterplotVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AbstractScatterplotVisualization.java new file mode 100644 index 00000000..cce9ea5d --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AbstractScatterplotVisualization.java @@ -0,0 +1,108 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.result.SamplingResult; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.projections.CanvasSize; +import de.lmu.ifi.dbs.elki.visualization.projections.Projection2D; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisualization; + +/** + * Default class to handle 2D projected visualizations. + * + * @author Erich Schubert + * + * @apiviz.landmark + * @apiviz.has Projection2D + */ +public abstract class AbstractScatterplotVisualization extends AbstractVisualization { + /** + * The current projection + */ + final protected Projection2D proj; + + /** + * The representation we visualize + */ + final protected Relation<? extends NumberVector<?, ?>> rel; + + /** + * The DBID sample + */ + final protected SamplingResult sample; + + /** + * Constructor. + * + * @param task Visualization task + */ + public AbstractScatterplotVisualization(VisualizationTask task) { + super(task); + this.proj = task.getProj(); + this.rel = task.getRelation(); + this.sample = ResultUtil.getSamplingResult(rel); + final double margin = context.getStyleLibrary().getSize(StyleLibrary.MARGIN); + this.layer = setupCanvas(svgp, proj, margin, task.getWidth(), task.getHeight()); + } + + /** + * Utility function to setup a canvas element for the visualization. + * + * @param svgp Plot element + * @param proj Projection to use + * @param margin Margin to use + * @param width Width + * @param height Height + * @return wrapper element with appropriate view box. + */ + public static Element setupCanvas(SVGPlot svgp, Projection2D proj, double margin, double width, double height) { + final CanvasSize canvas = proj.estimateViewport(); + final double sizex = canvas.getDiffX(); + final double sizey = canvas.getDiffY(); + String transform = SVGUtil.makeMarginTransform(width, height, sizex, sizey, margin) + " translate(" + SVGUtil.fmt(sizex / 2) + " " + SVGUtil.fmt(sizey / 2) + ")"; + + final Element layer = SVGUtil.svgElement(svgp.getDocument(), SVGConstants.SVG_G_TAG); + SVGUtil.setAtt(layer, SVGConstants.SVG_TRANSFORM_ATTRIBUTE, transform); + return layer; + } + + @Override + public void resultChanged(Result current) { + super.resultChanged(current); + if(current == proj) { + synchronizedRedraw(); + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AbstractTooltipVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AbstractTooltipVisualization.java new file mode 100644 index 00000000..8ce6ad67 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AbstractTooltipVisualization.java @@ -0,0 +1,185 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.events.Event; +import org.w3c.dom.events.EventListener; +import org.w3c.dom.events.EventTarget; + +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.logging.LoggingUtil; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; + +/** + * General base class for a tooltip visualizer. + * + * @author Erich Schubert + */ +// TODO: can we improve performance by not adding as many hovers? +public abstract class AbstractTooltipVisualization extends AbstractScatterplotVisualization implements DataStoreListener { + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String TOOLTIP_HIDDEN = "tooltip_hidden"; + + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String TOOLTIP_VISIBLE = "tooltip_visible"; + + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String TOOLTIP_STICKY = "tooltip_sticky"; + + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String TOOLTIP_AREA = "tooltip_area"; + + /** + * Our event listener. + */ + EventListener hoverer = new EventListener() { + @Override + public void handleEvent(Event evt) { + handleHoverEvent(evt); + } + }; + + /** + * Constructor. + * + * @param task Visualization task + */ + public AbstractTooltipVisualization(VisualizationTask task) { + super(task); + context.addDataStoreListener(this); + } + + @Override + public void destroy() { + super.destroy(); + context.removeDataStoreListener(this); + } + + @Override + public void redraw() { + setupCSS(svgp); + + double dotsize = context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT); + + for(DBID id : sample.getSample()) { + double[] v = proj.fastProjectDataToRenderSpace(rel.get(id)); + Element tooltip = makeTooltip(id, v[0], v[1], dotsize); + SVGUtil.addCSSClass(tooltip, TOOLTIP_HIDDEN); + + // sensitive area. + Element area = svgp.svgRect(v[0] - dotsize, v[1] - dotsize, 2 * dotsize, 2 * dotsize); + SVGUtil.addCSSClass(area, TOOLTIP_AREA); + + EventTarget targ = (EventTarget) area; + targ.addEventListener(SVGConstants.SVG_MOUSEOVER_EVENT_TYPE, hoverer, false); + targ.addEventListener(SVGConstants.SVG_MOUSEOUT_EVENT_TYPE, hoverer, false); + targ.addEventListener(SVGConstants.SVG_CLICK_EVENT_TYPE, hoverer, false); + + // NOTE: do not change the sequence in which these are inserted! + layer.appendChild(area); + layer.appendChild(tooltip); + } + } + + abstract protected Element makeTooltip(DBID id, double x, double y, double dotsize); + + /** + * Handle the hover events. + * + * @param evt Event. + */ + protected void handleHoverEvent(Event evt) { + if(evt.getTarget() instanceof Element) { + Element e = (Element) evt.getTarget(); + Node next = e.getNextSibling(); + if(next != null && next instanceof Element) { + toggleTooltip((Element) next, evt.getType()); + } + else { + LoggingUtil.warning("Tooltip sibling not found."); + } + } + else { + LoggingUtil.warning("Got event for non-Element?!?"); + } + } + + /** + * Toggle the Tooltip of an element. + * + * @param elem Element + * @param type Event type + */ + protected void toggleTooltip(Element elem, String type) { + String csscls = elem.getAttribute(SVGConstants.SVG_CLASS_ATTRIBUTE); + if(SVGConstants.SVG_MOUSEOVER_EVENT_TYPE.equals(type)) { + if(TOOLTIP_HIDDEN.equals(csscls)) { + SVGUtil.setAtt(elem, SVGConstants.SVG_CLASS_ATTRIBUTE, TOOLTIP_VISIBLE); + } + } + else if(SVGConstants.SVG_MOUSEOUT_EVENT_TYPE.equals(type)) { + if(TOOLTIP_VISIBLE.equals(csscls)) { + SVGUtil.setAtt(elem, SVGConstants.SVG_CLASS_ATTRIBUTE, TOOLTIP_HIDDEN); + } + } + else if(SVGConstants.SVG_CLICK_EVENT_TYPE.equals(type)) { + if(TOOLTIP_STICKY.equals(csscls)) { + SVGUtil.setAtt(elem, SVGConstants.SVG_CLASS_ATTRIBUTE, TOOLTIP_HIDDEN); + } + if(TOOLTIP_HIDDEN.equals(csscls) || TOOLTIP_VISIBLE.equals(csscls)) { + SVGUtil.setAtt(elem, SVGConstants.SVG_CLASS_ATTRIBUTE, TOOLTIP_STICKY); + } + } + } + + /** + * Registers the Tooltip-CSS-Class at a SVGPlot. + * + * @param svgp the SVGPlot to register the Tooltip-CSS-Class. + */ + abstract protected void setupCSS(SVGPlot svgp); + + @Override + public void resultChanged(Result current) { + if(sample == current) { + synchronizedRedraw(); + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AxisVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AxisVisualization.java new file mode 100644 index 00000000..a8f7fdca --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/AxisVisualization.java @@ -0,0 +1,158 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClassManager.CSSNamingConflict; +import de.lmu.ifi.dbs.elki.visualization.projections.Projection; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGSimpleLinearAxis; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; + +/** + * Generates a SVG-Element containing axes, including labeling. + * + * @author Remigius Wojdanowski + * + * @apiviz.uses SVGSimpleLinearAxis + */ +public class AxisVisualization extends AbstractScatterplotVisualization { + /** + * Constructor. + * + * @param task VisualizationTask + */ + public AxisVisualization(VisualizationTask task) { + super(task); + incrementalRedraw(); + } + + @Override + protected void redraw() { + int dim = DatabaseUtil.dimensionality(rel); + + // origin + double[] orig = proj.fastProjectScaledToRenderSpace(new double[dim]); + // diagonal point opposite to origin + double[] diag = new double[dim]; + for(int d2 = 0; d2 < dim; d2++) { + diag[d2] = 1; + } + diag = proj.fastProjectScaledToRenderSpace(diag); + // compute angle to diagonal line, used for axis labeling. + double diaga = Math.atan2(diag[1] - orig[1], diag[0] - orig[0]); + + double alfontsize = 1.1 * context.getStyleLibrary().getTextSize(StyleLibrary.AXIS_LABEL); + CSSClass alcls = new CSSClass(AxisVisualization.class, "unmanaged"); + alcls.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, SVGUtil.fmt(alfontsize)); + alcls.setStatement(SVGConstants.CSS_FILL_PROPERTY, context.getStyleLibrary().getTextColor(StyleLibrary.AXIS_LABEL)); + alcls.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, context.getStyleLibrary().getFontFamily(StyleLibrary.AXIS_LABEL)); + + // draw axes + for(int d = 0; d < dim; d++) { + double[] v = new double[dim]; + v[d] = 1; + // projected endpoint of axis + double[] ax = proj.fastProjectScaledToRenderSpace(v); + boolean righthand = false; + double axa = Math.atan2(ax[1] - orig[1], ax[0] - orig[0]); + if(axa > diaga || (diaga > 0 && axa > diaga + Math.PI)) { + righthand = true; + } + // System.err.println(ax.get(0) + " "+ ax.get(1)+ + // " "+(axa*180/Math.PI)+" "+(diaga*180/Math.PI)); + if(ax[0] != orig[0] || ax[1] != orig[1]) { + try { + SVGSimpleLinearAxis.drawAxis(svgp, layer, proj.getScale(d), orig[0], orig[1], ax[0], ax[1], righthand ? SVGSimpleLinearAxis.LabelStyle.RIGHTHAND : SVGSimpleLinearAxis.LabelStyle.LEFTHAND, context.getStyleLibrary()); + // TODO: move axis labeling into drawAxis function. + double offx = (righthand ? 1 : -1) * 0.02 * Projection.SCALE; + double offy = (righthand ? 1 : -1) * 0.02 * Projection.SCALE; + Element label = svgp.svgText(ax[0] + offx, ax[1] + offy, DatabaseUtil.getColumnLabel(rel, d + 1)); + SVGUtil.setAtt(label, SVGConstants.SVG_STYLE_ATTRIBUTE, alcls.inlineCSS()); + SVGUtil.setAtt(label, SVGConstants.SVG_TEXT_ANCHOR_ATTRIBUTE, righthand ? SVGConstants.SVG_START_VALUE : SVGConstants.SVG_END_VALUE); + layer.appendChild(label); + } + catch(CSSNamingConflict e) { + throw new RuntimeException("Conflict in CSS naming for axes.", e); + } + } + } + } + + /** + * Factory for axis visualizations + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses AxisVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * A short name characterizing this Visualizer. + */ + private static final String NAME = "Axes"; + + /** + * Constructor, adhering to + * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable} + */ + public Factory() { + super(); + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new AxisVisualization(task); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(result, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, p, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_BACKGROUND); + baseResult.getHierarchy().add(p, task); + } + } + + @Override + public boolean allowThumbnails(VisualizationTask task) { + // Don't use thumbnails + return false; + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/MarkerVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/MarkerVisualization.java new file mode 100644 index 00000000..7672ee93 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/MarkerVisualization.java @@ -0,0 +1,175 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.Iterator; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.exceptions.ObjectNotFoundException; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.ClassStylingPolicy; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.style.StyleResult; +import de.lmu.ifi.dbs.elki.visualization.style.StylingPolicy; +import de.lmu.ifi.dbs.elki.visualization.style.marker.MarkerLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; +import de.lmu.ifi.dbs.elki.visualization.visualizers.thumbs.ThumbnailVisualization; + +/** + * Visualize e.g. a clustering using different markers for different clusters. + * This visualizer is not constraint to clusters. It can in fact visualize any + * kind of result we have a style source for. + * + * @author Erich Schubert + * + * @apiviz.uses StyleResult + */ +public class MarkerVisualization extends AbstractScatterplotVisualization implements DataStoreListener { + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String DOTMARKER = "dot"; + + /** + * The result we visualize + */ + private StyleResult style; + + /** + * Constructor. + * + * @param task Visualization task + */ + public MarkerVisualization(VisualizationTask task) { + super(task); + this.style = task.getResult(); + context.addDataStoreListener(this); + context.addResultListener(this); + incrementalRedraw(); + } + + @Override + public void destroy() { + super.destroy(); + context.removeDataStoreListener(this); + context.removeResultListener(this); + } + + @Override + public void redraw() { + final MarkerLibrary ml = context.getStyleLibrary().markers(); + final double marker_size = context.getStyleLibrary().getSize(StyleLibrary.MARKERPLOT); + final StylingPolicy spol = style.getStylingPolicy(); + + if(spol instanceof ClassStylingPolicy) { + ClassStylingPolicy cspol = (ClassStylingPolicy) spol; + for(int cnum = cspol.getMinStyle(); cnum < cspol.getMaxStyle(); cnum++) { + for(Iterator<DBID> iter = cspol.iterateClass(cnum); iter.hasNext();) { + DBID cur = iter.next(); + try { + final NumberVector<?, ?> vec = rel.get(cur); + double[] v = proj.fastProjectDataToRenderSpace(vec); + ml.useMarker(svgp, layer, v[0], v[1], cnum, marker_size); + } + catch(ObjectNotFoundException e) { + // ignore. + } + } + } + } + else { + final String FILL = SVGConstants.CSS_FILL_PROPERTY + ":"; + // Color-based styling. Fall back to dots + for(DBID id : sample.getSample()) { + try { + double[] v = proj.fastProjectDataToRenderSpace(rel.get(id)); + Element dot = svgp.svgCircle(v[0], v[1], marker_size); + SVGUtil.addCSSClass(dot, DOTMARKER); + int col = spol.getColorForDBID(id); + SVGUtil.setAtt(dot, SVGConstants.SVG_STYLE_ATTRIBUTE, FILL + SVGUtil.colorToString(col)); + layer.appendChild(dot); + } + catch(ObjectNotFoundException e) { + // ignore. + } + } + } + } + + /** + * Visualization factory + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses MarkerVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * A short name characterizing this Visualizer. + */ + private static final String NAME = "Markers"; + + /** + * Constructor, adhering to + * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable} + */ + public Factory() { + super(); + thumbmask |= ThumbnailVisualization.ON_DATA | ThumbnailVisualization.ON_STYLE; + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new MarkerVisualization(task); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + // Find a style result to visualize: + IterableIterator<StyleResult> styleres = ResultUtil.filteredResults(result, StyleResult.class); + for(StyleResult c : styleres) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, c, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA); + baseResult.getHierarchy().add(c, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/PolygonVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/PolygonVisualization.java new file mode 100644 index 00000000..4dc78ecf --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/PolygonVisualization.java @@ -0,0 +1,183 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.ArrayList; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.spatial.Polygon; +import de.lmu.ifi.dbs.elki.data.spatial.PolygonsObject; +import de.lmu.ifi.dbs.elki.data.type.TypeUtil; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil; +import de.lmu.ifi.dbs.elki.utilities.exceptions.ObjectNotFoundException; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projections.Projection2D; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPath; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; + +/** + * Renders PolygonsObject in the data set. + * + * @author Erich Schubert + * + * @apiviz.has PolygonsObject - - visualizes + */ +public class PolygonVisualization extends AbstractScatterplotVisualization implements DataStoreListener { + /** + * A short name characterizing this Visualizer. + */ + private static final String NAME = "Polygons"; + + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String POLYS = "polys"; + + /** + * The current projection + */ + final protected Projection2D proj; + + /** + * The representation we visualize + */ + final protected Relation<PolygonsObject> rep; + + /** + * Constructor. + * + * @param task Task to visualize + */ + public PolygonVisualization(VisualizationTask task) { + super(task); + this.proj = task.getProj(); + this.rep = task.getResult(); // Note: relation was used for projection + context.addDataStoreListener(this); + incrementalRedraw(); + } + + @Override + public void destroy() { + super.destroy(); + context.removeDataStoreListener(this); + } + + @Override + public void redraw() { + CSSClass css = new CSSClass(svgp, POLYS); + // TODO: separate fill and line colors? + css.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.POLYGONS)); + css.setStatement(SVGConstants.CSS_STROKE_PROPERTY, context.getStyleLibrary().getColor(StyleLibrary.POLYGONS)); + css.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_NONE_VALUE); + svgp.addCSSClassOrLogError(css); + svgp.updateStyleElement(); + + // draw data + for(DBID id : rep.iterDBIDs()) { + try { + PolygonsObject poly = rep.get(id); + if(poly == null) { + continue; + } + SVGPath path = new SVGPath(); + for(Polygon ppoly : poly.getPolygons()) { + Vector first = ppoly.get(0); + double[] f = proj.fastProjectDataToRenderSpace(first.getArrayRef()); + path.moveTo(f[0], f[1]); + for(Vector v : ppoly) { + if(v == first) { + continue; + } + double[] p = proj.fastProjectDataToRenderSpace(v.getArrayRef()); + path.drawTo(p[0], p[1]); + } + // close path. + path.drawTo(f[0], f[1]); + } + Element e = path.makeElement(svgp); + SVGUtil.addCSSClass(e, POLYS); + layer.appendChild(e); + } + catch(ObjectNotFoundException e) { + // ignore. + } + } + } + + /** + * The visualization factory + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses PolygonVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Constructor + */ + public Factory() { + super(); + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new PolygonVisualization(task); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + ArrayList<Relation<?>> results = ResultUtil.filterResults(result, Relation.class); + for(Relation<?> rel : results) { + if(TypeUtil.POLYGON_TYPE.isAssignableFromType(rel.getDataTypeInformation())) { + // Assume that a 2d projector is using the same coordinates as the polygons. + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + if(DatabaseUtil.dimensionality(p.getRelation()) == 2) { + final VisualizationTask task = new VisualizationTask(NAME, rel, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA - 10); + baseResult.getHierarchy().add(rel, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/ReferencePointsVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/ReferencePointsVisualization.java new file mode 100644 index 00000000..644fc96f --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/ReferencePointsVisualization.java @@ -0,0 +1,144 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.Collection; +import java.util.Iterator; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.ReferencePointsResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; + +/** + * The actual visualization instance, for a single projection + * + * @author Erich Schubert + * + * @apiviz.has ReferencePointsResult oneway - - visualizes + */ +// TODO: add a result listener for the reference points. +public class ReferencePointsVisualization extends AbstractScatterplotVisualization { + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String REFPOINT = "refpoint"; + + /** + * A short name characterizing this Visualizer. + */ + private static final String NAME = "Reference Points"; + + /** + * Serves reference points. + */ + protected ReferencePointsResult<? extends NumberVector<?, ?>> result; + + /** + * Constructor. + * + * @param task Visualization task + */ + public ReferencePointsVisualization(VisualizationTask task) { + super(task); + this.result = task.getResult(); + incrementalRedraw(); + } + + @Override + public void redraw() { + setupCSS(svgp); + Iterator<? extends NumberVector<?, ?>> iter = result.iterator(); + + final double dotsize = context.getStyleLibrary().getSize(StyleLibrary.REFERENCE_POINTS); + while(iter.hasNext()) { + NumberVector<?, ?> v = iter.next(); + double[] projected = proj.fastProjectDataToRenderSpace(v); + Element dot = svgp.svgCircle(projected[0], projected[1], dotsize); + SVGUtil.addCSSClass(dot, REFPOINT); + layer.appendChild(dot); + } + } + + /** + * Registers the Reference-Point-CSS-Class at a SVGPlot. + * + * @param svgp the SVGPlot to register the -CSS-Class. + */ + private void setupCSS(SVGPlot svgp) { + CSSClass refpoint = new CSSClass(svgp, REFPOINT); + refpoint.setStatement(SVGConstants.CSS_FILL_PROPERTY, context.getStyleLibrary().getColor(StyleLibrary.REFERENCE_POINTS)); + svgp.addCSSClassOrLogError(refpoint); + } + + /** + * Generates a SVG-Element visualizing reference points. + * + * @author Remigius Wojdanowski + * + * @apiviz.stereotype factory + * @apiviz.uses ReferencePointsVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Constructor, adhering to + * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable} + */ + public Factory() { + super(); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + Collection<ReferencePointsResult<?>> rps = ResultUtil.filterResults(result, ReferencePointsResult.class); + for(ReferencePointsResult<?> rp : rps) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, rp, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA); + baseResult.getHierarchy().add(rp, task); + baseResult.getHierarchy().add(p, task); + } + } + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new ReferencePointsVisualization(task); + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/ToolBox2DVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/ToolBox2DVisualization.java new file mode 100644 index 00000000..7ec5f1ac --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/ToolBox2DVisualization.java @@ -0,0 +1,306 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2011
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+import org.w3c.dom.events.Event;
+import org.w3c.dom.events.EventListener;
+import org.w3c.dom.events.EventTarget;
+
+import de.lmu.ifi.dbs.elki.logging.Logging;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.utilities.FormatUtil;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projections.CanvasSize;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.VisualizerUtil;
+
+/**
+ * Renders a tool box on the left of the 2D visualization
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.has VisualizationTask oneway - - visualizes
+ */
+public class ToolBox2DVisualization extends AbstractScatterplotVisualization {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Tool Box";
+
+ /**
+ * The logger for this class.
+ */
+ private static final Logging logger = Logging.getLogger(Factory.class);
+
+ /**
+ * CSS class for a tool button
+ */
+ public static final String CSS_TOOL_BUTTON = "toolButton";
+
+ /**
+ * CSS class for the tool button caption
+ */
+ public static final String CSS_TOOL_CAPTION = "toolCaption";
+
+ /**
+ * CSS class for a tool button
+ */
+ public static final String CSS_TOOL_BUTTON_SELECTED = "toolButtonSelected";
+
+ /**
+ * The container
+ */
+ private Element container;
+
+ /**
+ * Constructor.
+ *
+ * @param task Task
+ */
+ public ToolBox2DVisualization(VisualizationTask task) {
+ super(task);
+ // TODO: which result do we best attach to?
+ context.addResultListener(this);
+ incrementalRedraw();
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+ container = svgp.svgElement(SVGConstants.SVG_G_TAG);
+ buildToolBox();
+ layer.appendChild(container);
+ }
+
+ /**
+ * Deletes the children of the container
+ *
+ * @param container Element to delete children
+ */
+ private void deleteChildren(Element container) {
+ while(container.hasChildNodes()) {
+ container.removeChild(container.getLastChild());
+ }
+ }
+
+ /**
+ * Build the toolbox
+ */
+ private void buildToolBox() {
+ double scale = StyleLibrary.SCALE;
+ deleteChildren(container);
+
+ ArrayList<VisualizationTask> vis = new ArrayList<VisualizationTask>();
+ final Iterable<VisualizationTask> visualizers = ResultUtil.filteredResults(task.getResult(), VisualizationTask.class);
+ for(VisualizationTask task : visualizers) {
+ if(VisualizerUtil.isTool(task) && !vis.contains(task)) {
+ vis.add(task);
+ }
+ }
+
+ // calculate the position of the first tool
+ CanvasSize viewport = proj.estimateViewport();
+ double x = viewport.getMinX() - 0.17 * scale;
+ double width = 0.07 * scale;
+ double height = 0.06 * scale;
+ double miny = viewport.getMinY();
+ double maxy = viewport.getMaxY();
+ double y = (miny + maxy) / 2 - (vis.size() * height * 1.4) / 2;
+ if(y < miny) {
+ logger.warning("Too many Tools");
+ }
+
+ // add tools
+ Element[] toolTags = new Element[vis.size()];
+ for(int i = 0; i < vis.size(); i++) {
+ VisualizationTask v = vis.get(i);
+ toolTags[i] = svgp.svgRect(x, y, width, height);
+ String name = v.getLongName();
+ // Split
+ List<String> lines = FormatUtil.splitAtLastBlank(name, 8);
+ // Generate label objects.
+ for(int l = 0; l < lines.size(); l++) {
+ Element selectRangeText = svgp.svgText(x + 0.01 * scale, y + (0.02 + 0.05 * l / lines.size()) * scale, lines.get(l));
+ SVGUtil.setAtt(selectRangeText, SVGConstants.SVG_CLASS_ATTRIBUTE, CSS_TOOL_CAPTION);
+ container.appendChild(selectRangeText);
+ }
+
+ if(VisualizerUtil.isVisible(v)) {
+ SVGUtil.addCSSClass(toolTags[i], CSS_TOOL_BUTTON_SELECTED);
+ }
+ else {
+ SVGUtil.addCSSClass(toolTags[i], CSS_TOOL_BUTTON);
+ }
+ addEventListener(toolTags[i], v);
+
+ container.appendChild(toolTags[i]);
+ y = y + 0.1 * scale;
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ private void addCSSClasses(SVGPlot svgp) {
+ // Class for the not selected tool
+ if(!svgp.getCSSClassManager().contains(CSS_TOOL_BUTTON)) {
+ final CSSClass modeCls = new CSSClass(this, CSS_TOOL_BUTTON);
+ modeCls.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, 0.4);
+ modeCls.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_GREEN_VALUE);
+ modeCls.setStatement(SVGConstants.CSS_CURSOR_PROPERTY, SVGConstants.CSS_POINTER_VALUE);
+
+ svgp.addCSSClassOrLogError(modeCls);
+ }
+ // Class for the selected tool
+ if(!svgp.getCSSClassManager().contains(CSS_TOOL_BUTTON_SELECTED)) {
+ final CSSClass modeCls = new CSSClass(this, CSS_TOOL_BUTTON_SELECTED);
+ modeCls.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, 0.4);
+ modeCls.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_BLUE_VALUE);
+ modeCls.setStatement(SVGConstants.CSS_STROKE_OPACITY_PROPERTY, 0.4);
+ modeCls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, SVGConstants.CSS_BLUE_VALUE);
+ modeCls.setStatement(SVGConstants.CSS_CURSOR_PROPERTY, SVGConstants.CSS_POINTER_VALUE);
+
+ svgp.addCSSClassOrLogError(modeCls);
+ }
+ // Class for the text of the tools
+ if(!svgp.getCSSClassManager().contains(CSS_TOOL_CAPTION)) {
+ final CSSClass label = new CSSClass(svgp, CSS_TOOL_CAPTION);
+ label.setStatement(SVGConstants.CSS_FILL_PROPERTY, context.getStyleLibrary().getTextColor(StyleLibrary.AXIS_LABEL));
+ label.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, context.getStyleLibrary().getFontFamily(StyleLibrary.AXIS_LABEL));
+ label.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, context.getStyleLibrary().getTextSize(StyleLibrary.AXIS_LABEL) * .8);
+
+ svgp.addCSSClassOrLogError(label);
+ }
+ }
+
+ /**
+ * Add an event listener to the Element
+ *
+ * @param tag Element to add the listener
+ * @param tool Tool represented by the Element
+ */
+ private void addEventListener(final Element tag, final VisualizationTask tool) {
+ EventTarget targ = (EventTarget) tag;
+ targ.addEventListener(SVGConstants.SVG_EVENT_CLICK, new EventListener() {
+ @Override
+ public void handleEvent(Event evt) {
+ handleMouseClick(tool);
+ }
+ }, false);
+ }
+
+ /**
+ * Handle the mouseClick - change the selected tool in the context
+ *
+ * @param tool Selected Tool
+ */
+ protected void handleMouseClick(VisualizationTask tool) {
+ // TODO: Move this to the selected tool instead?
+ if(VisualizerUtil.isVisible(tool)) {
+ context.setSelection(null);
+ }
+ VisualizerUtil.setVisible(context, tool, true);
+ }
+
+ @Override
+ public void resultAdded(Result child, Result parent) {
+ if(child instanceof VisualizationTask) {
+ VisualizationTask task = (VisualizationTask) child;
+ if(VisualizerUtil.isTool(task)) {
+ synchronizedRedraw();
+ }
+ }
+ }
+
+ @Override
+ public void resultRemoved(Result child, Result parent) {
+ if(child instanceof VisualizationTask) {
+ VisualizationTask task = (VisualizationTask) child;
+ if(VisualizerUtil.isTool(task)) {
+ synchronizedRedraw();
+ }
+ }
+ }
+
+ @Override
+ public void resultChanged(Result current) {
+ if(current instanceof VisualizationTask) {
+ VisualizationTask task = (VisualizationTask) current;
+ if(VisualizerUtil.isTool(task)) {
+ synchronizedRedraw();
+ }
+ }
+ }
+
+ /**
+ * Factory for visualizers for a toolbox
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses ToolBox2DVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Constructor
+ */
+ public Factory() {
+ super();
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new ToolBox2DVisualization(task);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(result, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, p, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_INTERACTIVE);
+ task.put(VisualizationTask.META_NOTHUMB, true);
+ task.put(VisualizationTask.META_NOEXPORT, true);
+ task.put(VisualizationTask.META_NOEMBED, true);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/TooltipScoreVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/TooltipScoreVisualization.java new file mode 100644 index 00000000..838390d0 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/TooltipScoreVisualization.java @@ -0,0 +1,252 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.text.NumberFormat; +import java.util.List; +import java.util.Locale; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.type.TypeUtil; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.GreaterEqualConstraint; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; + +/** + * Generates a SVG-Element containing Tooltips. Tooltips remain invisible until + * their corresponding Marker is touched by the cursor and stay visible as long + * as the cursor lingers on the marker. + * + * @author Remigius Wojdanowski + */ +public class TooltipScoreVisualization extends AbstractTooltipVisualization { + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME = "Outlier Score Tooltips"; + + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME_GEN = "Score Tooltips"; + + /** + * Number format. + */ + NumberFormat nf; + + /** + * Number value to visualize + */ + private Relation<? extends Number> result; + + /** + * Font size to use. + */ + private double fontsize; + + /** + * Constructor + * + * @param task Task + * @param nf Number Format + */ + public TooltipScoreVisualization(VisualizationTask task, NumberFormat nf) { + super(task); + this.result = task.getResult(); + this.nf = nf; + this.fontsize = 3 * context.getStyleLibrary().getTextSize(StyleLibrary.PLOT); + synchronizedRedraw(); + } + + @Override + protected Element makeTooltip(DBID id, double x, double y, double dotsize) { + return svgp.svgText(x + dotsize, y + fontsize * 0.07, nf.format(result.get(id).doubleValue())); + } + + /** + * Registers the Tooltip-CSS-Class at a SVGPlot. + * + * @param svgp the SVGPlot to register the Tooltip-CSS-Class. + */ + @Override + protected void setupCSS(SVGPlot svgp) { + final StyleLibrary style = context.getStyleLibrary(); + final double fontsize = style.getTextSize(StyleLibrary.PLOT); + final String fontfamily = style.getFontFamily(StyleLibrary.PLOT); + + CSSClass tooltiphidden = new CSSClass(svgp, TOOLTIP_HIDDEN); + tooltiphidden.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, fontsize); + tooltiphidden.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, fontfamily); + tooltiphidden.setStatement(SVGConstants.CSS_DISPLAY_PROPERTY, SVGConstants.CSS_NONE_VALUE); + svgp.addCSSClassOrLogError(tooltiphidden); + + CSSClass tooltipvisible = new CSSClass(svgp, TOOLTIP_VISIBLE); + tooltipvisible.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, fontsize); + tooltipvisible.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, fontfamily); + svgp.addCSSClassOrLogError(tooltipvisible); + + CSSClass tooltipsticky = new CSSClass(svgp, TOOLTIP_STICKY); + tooltipsticky.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, fontsize); + tooltipsticky.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, fontfamily); + svgp.addCSSClassOrLogError(tooltipsticky); + + // invisible but sensitive area for the tooltip activator + CSSClass tooltiparea = new CSSClass(svgp, TOOLTIP_AREA); + tooltiparea.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_RED_VALUE); + tooltiparea.setStatement(SVGConstants.CSS_STROKE_PROPERTY, SVGConstants.CSS_NONE_VALUE); + tooltiparea.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, "0"); + tooltiparea.setStatement(SVGConstants.CSS_CURSOR_PROPERTY, SVGConstants.CSS_POINTER_VALUE); + svgp.addCSSClassOrLogError(tooltiparea); + } + + /** + * Factory for tooltip visualizers + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses TooltipScoreVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Parameter for the gamma-correction. + * + * <p> + * Key: {@code -tooltip.digits} + * </p> + * + * <p> + * Default value: 4 + * </p> + */ + public static final OptionID DIGITS_ID = OptionID.getOrCreateOptionID("tooltip.digits", "Number of digits to show (e.g. when visualizing outlier scores)"); + + /** + * Number formatter used for visualization + */ + NumberFormat nf = null; + + /** + * Constructor. + * + * @param digits number of digits + */ + public Factory(int digits) { + super(); + nf = NumberFormat.getInstance(Locale.ROOT); + nf.setGroupingUsed(false); + nf.setMaximumFractionDigits(digits); + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new TooltipScoreVisualization(task, nf); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + // TODO: we can also visualize other scores! + List<OutlierResult> ors = ResultUtil.filterResults(result, OutlierResult.class); + for(OutlierResult o : ors) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, o.getScores(), p.getRelation(), this); + task.put(VisualizationTask.META_TOOL, true); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + baseResult.getHierarchy().add(o.getScores(), task); + baseResult.getHierarchy().add(p, task); + } + } + List<Relation<?>> rrs = ResultUtil.filterResults(result, Relation.class); + for(Relation<?> r : rrs) { + if(!TypeUtil.DOUBLE.isAssignableFromType(r.getDataTypeInformation())) { + continue; + } + // Skip if we already considered it above + boolean add = true; + for(Result p : baseResult.getHierarchy().getChildren(r)) { + if(p instanceof VisualizationTask && ((VisualizationTask) p).getFactory() instanceof Factory) { + add = false; + break; + } + } + if(add) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME_GEN, r, p.getRelation(), this); + task.put(VisualizationTask.META_TOOL, true); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + baseResult.getHierarchy().add(r, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } + + /** + * Parameterization class. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class Parameterizer extends AbstractParameterizer { + protected int digits = 4; + + @Override + protected void makeOptions(Parameterization config) { + super.makeOptions(config); + IntParameter DIGITS_PARAM = new IntParameter(DIGITS_ID, new GreaterEqualConstraint(0), 4); + + if(config.grab(DIGITS_PARAM)) { + digits = DIGITS_PARAM.getValue(); + } + } + + @Override + protected Factory makeInstance() { + return new Factory(digits); + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/TooltipStringVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/TooltipStringVisualization.java new file mode 100644 index 00000000..9baea926 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/TooltipStringVisualization.java @@ -0,0 +1,222 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.ArrayList; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.ClassLabel; +import de.lmu.ifi.dbs.elki.data.ExternalID; +import de.lmu.ifi.dbs.elki.data.LabelList; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; + +/** + * Generates a SVG-Element containing Tooltips. Tooltips remain invisible until + * their corresponding Marker is touched by the cursor and stay visible as long + * as the cursor lingers on the marker. + * + * @author Remigius Wojdanowski + * @author Erich Schubert + * + * @apiviz.has Relation oneway - - visualizes + */ +public class TooltipStringVisualization extends AbstractTooltipVisualization { + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME_ID = "ID Tooltips"; + + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME_LABEL = "Object Label Tooltips"; + + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME_CLASS = "Class Label Tooltips"; + + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME_EID = "External ID Tooltips"; + + /** + * Number value to visualize + */ + private Relation<?> result; + + /** + * Font size to use. + */ + private double fontsize; + + /** + * Constructor. + * + * @param task Task + */ + public TooltipStringVisualization(VisualizationTask task) { + super(task); + this.result = task.getResult(); + this.fontsize = 3 * context.getStyleLibrary().getTextSize(StyleLibrary.PLOT); + synchronizedRedraw(); + } + + @Override + protected Element makeTooltip(DBID id, double x, double y, double dotsize) { + final Object data = result.get(id); + String label; + if(data == null) { + label = "null"; + } + else { + label = data.toString(); + } + if(label == "" || label == null) { + label = "null"; + } + return svgp.svgText(x + dotsize, y + fontsize * 0.07, label); + } + + /** + * Registers the Tooltip-CSS-Class at a SVGPlot. + * + * @param svgp the SVGPlot to register the Tooltip-CSS-Class. + */ + @Override + protected void setupCSS(SVGPlot svgp) { + final StyleLibrary style = context.getStyleLibrary(); + final double fontsize = style.getTextSize(StyleLibrary.PLOT); + final String fontfamily = style.getFontFamily(StyleLibrary.PLOT); + + CSSClass tooltiphidden = new CSSClass(svgp, TOOLTIP_HIDDEN); + tooltiphidden.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, fontsize); + tooltiphidden.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, fontfamily); + tooltiphidden.setStatement(SVGConstants.CSS_DISPLAY_PROPERTY, SVGConstants.CSS_NONE_VALUE); + svgp.addCSSClassOrLogError(tooltiphidden); + + CSSClass tooltipvisible = new CSSClass(svgp, TOOLTIP_VISIBLE); + tooltipvisible.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, fontsize); + tooltipvisible.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, fontfamily); + svgp.addCSSClassOrLogError(tooltipvisible); + + CSSClass tooltipsticky = new CSSClass(svgp, TOOLTIP_STICKY); + tooltipsticky.setStatement(SVGConstants.CSS_FONT_SIZE_PROPERTY, fontsize); + tooltipsticky.setStatement(SVGConstants.CSS_FONT_FAMILY_PROPERTY, fontfamily); + svgp.addCSSClassOrLogError(tooltipsticky); + + // invisible but sensitive area for the tooltip activator + CSSClass tooltiparea = new CSSClass(svgp, TOOLTIP_AREA); + tooltiparea.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_RED_VALUE); + tooltiparea.setStatement(SVGConstants.CSS_STROKE_PROPERTY, SVGConstants.CSS_NONE_VALUE); + tooltiparea.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, "0"); + tooltiparea.setStatement(SVGConstants.CSS_CURSOR_PROPERTY, SVGConstants.CSS_POINTER_VALUE); + svgp.addCSSClassOrLogError(tooltiparea); + } + + /** + * Factory + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses TooltipStringVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Constructor, adhering to + * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable} + */ + public Factory() { + super(); + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new TooltipStringVisualization(task); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + ArrayList<Relation<?>> reps = ResultUtil.filterResults(result, Relation.class); + for(Relation<?> rep : reps) { + if(DBID.class.isAssignableFrom(rep.getDataTypeInformation().getRestrictionClass())) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME_ID, rep, p.getRelation(), this); + task.put(VisualizationTask.META_TOOL, true); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + baseResult.getHierarchy().add(rep, task); + baseResult.getHierarchy().add(p, task); + } + } + if(ClassLabel.class.isAssignableFrom(rep.getDataTypeInformation().getRestrictionClass())) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME_CLASS, rep, p.getRelation(), this); + task.put(VisualizationTask.META_TOOL, true); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + baseResult.getHierarchy().add(rep, task); + baseResult.getHierarchy().add(p, task); + } + } + if(LabelList.class.isAssignableFrom(rep.getDataTypeInformation().getRestrictionClass())) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME_LABEL, rep, p.getRelation(), this); + task.put(VisualizationTask.META_TOOL, true); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + baseResult.getHierarchy().add(rep, task); + baseResult.getHierarchy().add(p, task); + } + } + if(ExternalID.class.isAssignableFrom(rep.getDataTypeInformation().getRestrictionClass())) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME_EID, rep, p.getRelation(), this); + task.put(VisualizationTask.META_TOOL, true); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + baseResult.getHierarchy().add(rep, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterHullVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterHullVisualization.java new file mode 100644 index 00000000..430ab194 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterHullVisualization.java @@ -0,0 +1,276 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2011
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+
+import de.lmu.ifi.dbs.elki.data.Cluster;
+import de.lmu.ifi.dbs.elki.data.Clustering;
+import de.lmu.ifi.dbs.elki.data.model.Model;
+import de.lmu.ifi.dbs.elki.data.spatial.Polygon;
+import de.lmu.ifi.dbs.elki.data.spatial.SpatialUtil;
+import de.lmu.ifi.dbs.elki.database.ids.DBID;
+import de.lmu.ifi.dbs.elki.database.ids.DBIDs;
+import de.lmu.ifi.dbs.elki.math.geometry.AlphaShape;
+import de.lmu.ifi.dbs.elki.math.geometry.GrahamScanConvexHull2D;
+import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.colors.ColorLibrary;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projections.CanvasSize;
+import de.lmu.ifi.dbs.elki.visualization.projections.Projection;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPath;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+
+/**
+ * Visualizer for generating an SVG-Element containing the convex hull / alpha
+ * shape of each cluster.
+ *
+ * @author Robert Rödler
+ * @author Erich Schubert
+ *
+ * @apiviz.has Clustering oneway - - visualizes
+ * @apiviz.uses ConvexHull2D
+ * @apiviz.uses AlphaShape
+ */
+public class ClusterHullVisualization extends AbstractScatterplotVisualization {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Cluster Hull Visualization";
+
+ /**
+ * Generic tags to indicate the type of element. Used in IDs, CSS-Classes etc.
+ */
+ public static final String CLUSTERHULL = "cluster-hull";
+
+ /**
+ * The result we work on
+ */
+ Clustering<Model> clustering;
+
+ /**
+ * Alpha value
+ */
+ double alpha = Double.POSITIVE_INFINITY;
+
+ /**
+ * Constructor
+ *
+ * @param task VisualizationTask
+ * @param alpha Alpha value
+ */
+ public ClusterHullVisualization(VisualizationTask task, double alpha) {
+ super(task);
+ this.clustering = task.getResult();
+ this.alpha = alpha;
+ incrementalRedraw();
+ }
+
+ @Override
+ protected void redraw() {
+ // Viewport size, for "relative size" computations
+ final CanvasSize viewp = proj.estimateViewport();
+ double projarea = viewp.getDiffX() * viewp.getDiffY();
+
+ double opacity = 0.25;
+
+ Iterator<Cluster<Model>> ci = clustering.getAllClusters().iterator();
+
+ for(int cnum = 0; cnum < clustering.getAllClusters().size(); cnum++) {
+ Cluster<?> clus = ci.next();
+ final DBIDs ids = clus.getIDs();
+
+ if(alpha >= Double.POSITIVE_INFINITY) {
+ GrahamScanConvexHull2D hull = new GrahamScanConvexHull2D();
+
+ for(DBID clpnum : ids) {
+ double[] projP = proj.fastProjectDataToRenderSpace(rel.get(clpnum));
+ hull.add(new Vector(projP));
+ }
+ Polygon chres = hull.getHull();
+
+ // Plot the convex hull:
+ if(chres != null && chres.size() > 1) {
+ SVGPath path = new SVGPath(chres);
+ // Approximate area (using bounding box)
+ double hullarea = SpatialUtil.volume(chres);
+ final double relativeArea = (projarea - hullarea) / projarea;
+ final double relativeSize = (double) ids.size() / rel.size();
+ opacity = Math.sqrt(relativeSize * relativeArea);
+
+ Element hulls = path.makeElement(svgp);
+ addCSSClasses(svgp, cnum, opacity);
+ SVGUtil.addCSSClass(hulls, CLUSTERHULL + cnum);
+ layer.appendChild(hulls);
+ }
+ }
+ else {
+ ArrayList<Vector> ps = new ArrayList<Vector>(ids.size());
+ for(DBID clpnum : ids) {
+ double[] projP = proj.fastProjectDataToRenderSpace(rel.get(clpnum));
+ ps.add(new Vector(projP));
+ }
+ List<Polygon> polys = (new AlphaShape(ps, alpha * Projection.SCALE)).compute();
+ for(Polygon p : polys) {
+ SVGPath path = new SVGPath(p);
+ Element hulls = path.makeElement(svgp);
+ addCSSClasses(svgp, cnum, 0.5);
+ SVGUtil.addCSSClass(hulls, CLUSTERHULL + cnum);
+ layer.appendChild(hulls);
+ }
+ }
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ private void addCSSClasses(SVGPlot svgp, int clusterID, double opac) {
+ ColorLibrary colors = context.getStyleLibrary().getColorSet(StyleLibrary.PLOT);
+
+ CSSClass cls = new CSSClass(this, CLUSTERHULL + clusterID);
+ cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT));
+
+ final String color;
+ if(clustering.getAllClusters().size() == 1) {
+ color = "black";
+ }
+ else {
+ color = colors.getColor(clusterID);
+ }
+ cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, color);
+ cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, color);
+ cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, opac);
+
+ svgp.addCSSClassOrLogError(cls);
+ }
+
+ /**
+ * Factory for visualizers to generate an SVG-Element containing the convex
+ * hull or alpha shape of a cluster.
+ *
+ * @author Robert Rödler
+ * @author Erich Schubert
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses ClusterHullVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Alpha value
+ */
+ double alpha = Double.POSITIVE_INFINITY;
+
+ /**
+ * Constructor.
+ *
+ * @param alpha Alpha value
+ */
+ public Factory(double alpha) {
+ super();
+ this.alpha = alpha;
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new ClusterHullVisualization(task, alpha);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ // Find clusterings we can visualize:
+ Collection<Clustering<?>> clusterings = ResultUtil.filterResults(result, Clustering.class);
+ for(Clustering<?> c : clusterings) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, c, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA - 1);
+ task.put(VisualizationTask.META_VISIBLE_DEFAULT, false);
+ baseResult.getHierarchy().add(c, task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+
+ /**
+ * Parameterization class.
+ *
+ * @author Erich Schubert
+ *
+ * @apiviz.exclude
+ */
+ public static class Parameterizer extends AbstractParameterizer {
+ /**
+ * Alpha-Value for alpha-shapes
+ *
+ * <p>
+ * Key: {@code -hull.alpha}
+ * </p>
+ */
+ public static final OptionID ALPHA_ID = OptionID.getOrCreateOptionID("hull.alpha", "Alpha value for hull drawing (in projected space!).");
+
+ /**
+ * Alpha value
+ */
+ double alpha = Double.POSITIVE_INFINITY;
+
+ @Override
+ protected void makeOptions(Parameterization config) {
+ super.makeOptions(config);
+ DoubleParameter alphaP = new DoubleParameter(ALPHA_ID, Double.POSITIVE_INFINITY);
+ if(config.grab(alphaP)) {
+ alpha = alphaP.getValue();
+ }
+ }
+
+ @Override
+ protected Factory makeInstance() {
+ return new Factory(alpha);
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterMeanVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterMeanVisualization.java new file mode 100644 index 00000000..c9443a9f --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterMeanVisualization.java @@ -0,0 +1,281 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2011
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.Iterator;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+
+import de.lmu.ifi.dbs.elki.data.Cluster;
+import de.lmu.ifi.dbs.elki.data.Clustering;
+import de.lmu.ifi.dbs.elki.data.NumberVector;
+import de.lmu.ifi.dbs.elki.data.model.MeanModel;
+import de.lmu.ifi.dbs.elki.database.ids.DBID;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.colors.ColorLibrary;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.style.marker.MarkerLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPath;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+
+/**
+ * Visualize the mean of a KMeans-Clustering
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.has MeanModel oneway - - visualizes
+ */
+public class ClusterMeanVisualization extends AbstractScatterplotVisualization {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Cluster Means";
+
+ /**
+ * CSS class name for center of the means
+ */
+ private final static String CSS_MEAN_CENTER = "mean-center";
+
+ /**
+ * CSS class name for center of the means
+ */
+ private final static String CSS_MEAN = "mean-marker";
+
+ /**
+ * CSS class name for center of the means
+ */
+ private final static String CSS_MEAN_STAR = "mean-star";
+
+ /**
+ * Clustering to visualize.
+ */
+ Clustering<MeanModel<? extends NumberVector<?, ?>>> clustering;
+
+ /**
+ * Draw stars
+ */
+ boolean stars;
+
+ /**
+ * Constructor.
+ *
+ * @param task Visualization task
+ * @param stars Draw stars
+ */
+ public ClusterMeanVisualization(VisualizationTask task, boolean stars) {
+ super(task);
+ this.clustering = task.getResult();
+ this.stars = stars;
+ incrementalRedraw();
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+
+ MarkerLibrary ml = context.getStyleLibrary().markers();
+ double marker_size = context.getStyleLibrary().getSize(StyleLibrary.MARKERPLOT);
+
+ Iterator<Cluster<MeanModel<? extends NumberVector<?, ?>>>> ci = clustering.getAllClusters().iterator();
+ for(int cnum = 0; ci.hasNext(); cnum++) {
+ Cluster<MeanModel<? extends NumberVector<?, ?>>> clus = ci.next();
+ double[] mean = proj.fastProjectDataToRenderSpace(clus.getModel().getMean());
+
+ // add a greater Marker for the mean
+ Element meanMarker = ml.useMarker(svgp, layer, mean[0], mean[1], cnum, marker_size * 3);
+ SVGUtil.setAtt(meanMarker, SVGConstants.SVG_CLASS_ATTRIBUTE, CSS_MEAN);
+
+ // Add a fine cross to mark the exact location of the mean.
+ Element meanMarkerCenter = svgp.svgLine(mean[0] - .7, mean[1], mean[0] + .7, mean[1]);
+ SVGUtil.setAtt(meanMarkerCenter, SVGConstants.SVG_CLASS_ATTRIBUTE, CSS_MEAN_CENTER);
+ Element meanMarkerCenter2 = svgp.svgLine(mean[0], mean[1] - .7, mean[0], mean[1] + .7);
+ SVGUtil.setAtt(meanMarkerCenter2, SVGConstants.SVG_CLASS_ATTRIBUTE, CSS_MEAN_CENTER);
+
+ layer.appendChild(meanMarkerCenter);
+ layer.appendChild(meanMarkerCenter2);
+
+ if(stars) {
+ SVGPath star = new SVGPath();
+ for(DBID id : clus.getIDs()) {
+ double[] obj = proj.fastProjectDataToRenderSpace(rel.get(id));
+ star.moveTo(mean);
+ star.drawTo(obj);
+ }
+ Element stare = star.makeElement(svgp);
+ SVGUtil.setCSSClass(stare, CSS_MEAN_STAR + "_" + cnum);
+ layer.appendChild(stare);
+ }
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ private void addCSSClasses(SVGPlot svgp) {
+ if(!svgp.getCSSClassManager().contains(CSS_MEAN_CENTER)) {
+ CSSClass center = new CSSClass(this, CSS_MEAN_CENTER);
+ center.setStatement(SVGConstants.CSS_STROKE_PROPERTY, context.getStyleLibrary().getTextColor(StyleLibrary.DEFAULT));
+ center.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.AXIS_TICK) / 2);
+ svgp.addCSSClassOrLogError(center);
+ }
+ if(!svgp.getCSSClassManager().contains(CSS_MEAN)) {
+ CSSClass center = new CSSClass(this, CSS_MEAN);
+ center.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, "0.7");
+ svgp.addCSSClassOrLogError(center);
+ }
+ if(stars) {
+ ColorLibrary colors = context.getStyleLibrary().getColorSet(StyleLibrary.PLOT);
+
+ Iterator<Cluster<MeanModel<? extends NumberVector<?, ?>>>> ci = clustering.getAllClusters().iterator();
+ for(int cnum = 0; ci.hasNext(); cnum++) {
+ ci.next();
+ if(!svgp.getCSSClassManager().contains(CSS_MEAN_STAR + "_" + cnum)) {
+ CSSClass center = new CSSClass(this, CSS_MEAN_STAR + "_" + cnum);
+ center.setStatement(SVGConstants.CSS_STROKE_PROPERTY, colors.getColor(cnum));
+ center.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT));
+ center.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, "0.7");
+ svgp.addCSSClassOrLogError(center);
+ }
+ }
+ }
+ }
+
+ /**
+ * Factory for visualizers to generate an SVG-Element containing a marker for
+ * the mean in a KMeans-Clustering
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses ClusterMeanVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Option ID for visualization of cluster means.
+ *
+ * <pre>
+ * -cluster.stars
+ * </pre>
+ */
+ public static final OptionID STARS_ID = OptionID.getOrCreateOptionID("cluster.stars", "Visualize mean-based clusters using stars.");
+
+ /**
+ * Draw stars
+ */
+ private boolean stars;
+
+ /**
+ * Constructor.
+ *
+ * @param stars Draw stars
+ */
+ public Factory(boolean stars) {
+ super();
+ this.stars = stars;
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new ClusterMeanVisualization(task, stars);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ // Find clusterings we can visualize:
+ Iterator<Clustering<?>> clusterings = ResultUtil.filteredResults(result, Clustering.class);
+ while(clusterings.hasNext()) {
+ Clustering<?> c = clusterings.next();
+ if(c.getAllClusters().size() > 0) {
+ // Does the cluster have a model with cluster means?
+ Clustering<MeanModel<? extends NumberVector<?, ?>>> mcls = findMeanModel(c);
+ if(mcls != null) {
+ Iterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ while(ps.hasNext()) {
+ ScatterPlotProjector<?> p = ps.next();
+ final VisualizationTask task = new VisualizationTask(NAME, c, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA + 1);
+ baseResult.getHierarchy().add(c, task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Test if the given clustering has a mean model.
+ *
+ * @param c Clustering to inspect
+ * @return the clustering cast to return a mean model, null otherwise.
+ */
+ @SuppressWarnings("unchecked")
+ private static Clustering<MeanModel<? extends NumberVector<?, ?>>> findMeanModel(Clustering<?> c) {
+ if(c.getAllClusters().get(0).getModel() instanceof MeanModel<?>) {
+ return (Clustering<MeanModel<? extends NumberVector<?, ?>>>) c;
+ }
+ return null;
+ }
+
+ /**
+ * Parameterization class.
+ *
+ * @author Erich Schubert
+ *
+ * @apiviz.exclude
+ */
+ public static class Parameterizer extends AbstractParameterizer {
+ protected boolean stars = false;
+
+ @Override
+ protected void makeOptions(Parameterization config) {
+ super.makeOptions(config);
+ Flag starsF = new Flag(STARS_ID);
+ if(config.grab(starsF)) {
+ stars = starsF.getValue();
+ }
+ }
+
+ @Override
+ protected Factory makeInstance() {
+ return new Factory(stars);
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterOrderVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterOrderVisualization.java new file mode 100644 index 00000000..1ac55851 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/ClusterOrderVisualization.java @@ -0,0 +1,149 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.Collection; + +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.distance.distancevalue.DoubleDistance; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.result.optics.ClusterOrderEntry; +import de.lmu.ifi.dbs.elki.result.optics.ClusterOrderResult; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; +import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization; + +/** + * Cluster order visualizer. + * + * @author Erich Schubert + * + * @apiviz.has ClusterOrderResult oneway - - visualizes + */ +// TODO: listen for CLUSTER ORDER changes. +public class ClusterOrderVisualization extends AbstractScatterplotVisualization implements DataStoreListener { + /** + * A short name characterizing this Visualizer. + */ + private static final String NAME = "Predecessor Graph"; + + /** + * CSS class name + */ + private static final String CSSNAME = "predecessor"; + + /** + * The result we visualize + */ + protected ClusterOrderResult<?> result; + + public ClusterOrderVisualization(VisualizationTask task) { + super(task); + result = task.getResult(); + context.addDataStoreListener(this); + incrementalRedraw(); + } + + @Override + public void destroy() { + super.destroy(); + context.removeDataStoreListener(this); + } + + @Override + public void redraw() { + CSSClass cls = new CSSClass(this, CSSNAME); + context.getStyleLibrary().lines().formatCSSClass(cls, 0, context.getStyleLibrary().getLineWidth(StyleLibrary.CLUSTERORDER)); + + svgp.addCSSClassOrLogError(cls); + + for(ClusterOrderEntry<?> ce : result) { + DBID thisId = ce.getID(); + DBID prevId = ce.getPredecessorID(); + if(thisId == null || prevId == null) { + continue; + } + double[] thisVec = proj.fastProjectDataToRenderSpace(rel.get(thisId)); + double[] prevVec = proj.fastProjectDataToRenderSpace(rel.get(prevId)); + + // FIXME: DO NOT COMMIT + thisVec[0] = thisVec[0] * 0.95 + prevVec[0] * 0.05; + thisVec[1] = thisVec[1] * 0.95 + prevVec[1] * 0.05; + + Element arrow = svgp.svgLine(prevVec[0], prevVec[1], thisVec[0], thisVec[1]); + SVGUtil.setCSSClass(arrow, cls.getName()); + + layer.appendChild(arrow); + } + } + + /** + * Visualize an OPTICS cluster order by drawing connection lines. + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses ClusterOrderVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Constructor, adhering to + * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable} + */ + public Factory() { + super(); + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new ClusterOrderVisualization(task); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + Collection<ClusterOrderResult<DoubleDistance>> cos = ResultUtil.filterResults(result, ClusterOrderResult.class); + for(ClusterOrderResult<DoubleDistance> co : cos) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, co, p.getRelation(), this); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA - 1); + baseResult.getHierarchy().add(co, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/EMClusterVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/EMClusterVisualization.java new file mode 100644 index 00000000..6b2f43a3 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/EMClusterVisualization.java @@ -0,0 +1,473 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.Cluster; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.data.model.EMModel; +import de.lmu.ifi.dbs.elki.data.model.MeanModel; +import de.lmu.ifi.dbs.elki.data.model.Model; +import de.lmu.ifi.dbs.elki.data.spatial.Polygon; +import de.lmu.ifi.dbs.elki.database.ids.DBIDs; +import de.lmu.ifi.dbs.elki.logging.LoggingUtil; +import de.lmu.ifi.dbs.elki.math.MathUtil; +import de.lmu.ifi.dbs.elki.math.geometry.GrahamScanConvexHull2D; +import de.lmu.ifi.dbs.elki.math.linearalgebra.EigenPair; +import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; +import de.lmu.ifi.dbs.elki.math.linearalgebra.SortedEigenPairs; +import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCARunner; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.EmptyParameterization; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.colors.ColorLibrary; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGHyperSphere; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPath; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization; + +/** + * Visualizer for generating SVG-Elements containing ellipses for first, second + * and third standard deviation + * + * @author Robert Rödler + * + * @apiviz.has EMModel oneway - - visualizes + * @apiviz.uses ConvexHull2D + * + * @param <NV> Type of the NumberVector being visualized. + */ +// TODO: nicer stacking of n-fold hulls +// TODO: can we find a proper sphere for 3+ dimensions? +public class EMClusterVisualization<NV extends NumberVector<NV, ?>> extends AbstractScatterplotVisualization { + /** + * A short name characterizing this Visualizer. + */ + private static final String NAME = "EM Cluster Visualization"; + + /** + * Generic tags to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String EMBORDER = "EMClusterBorder"; + + /** + * The result we work on + */ + Clustering<EMModel<NV>> clustering; + + private static final double KAPPA = SVGHyperSphere.EUCLIDEAN_KAPPA; + + /** + * StyleParameter: + */ + private int times = 3; + + private int opacStyle = 1; + + private int softBorder = 1; + + private int drawStyle = 0; + + final static double[] sigma = new double[] { 0.41, 0.223, 0.047 }; + + /** + * Constructor + * + * @param task VisualizationTask + */ + public EMClusterVisualization(VisualizationTask task) { + super(task); + this.clustering = task.getResult(); + incrementalRedraw(); + } + + @Override + protected void redraw() { + // set styles + addCSSClasses(svgp); + + // PCARunner + PCARunner<NV> pcarun = ClassGenericsUtil.parameterizeOrAbort(PCARunner.class, new EmptyParameterization()); + + Iterator<Cluster<EMModel<NV>>> ci = clustering.getAllClusters().iterator(); + for(int cnum = 0; cnum < clustering.getAllClusters().size(); cnum++) { + Cluster<EMModel<NV>> clus = ci.next(); + DBIDs ids = clus.getIDs(); + + if(ids.size() > 0) { + Matrix covmat = clus.getModel().getCovarianceMatrix(); + NV centroid = clus.getModel().getMean(); + Vector cent = new Vector(proj.fastProjectDataToRenderSpace(centroid)); + + // Compute the eigenvectors + SortedEigenPairs eps = pcarun.processCovarMatrix(covmat).getEigenPairs(); + + Vector[] pc = new Vector[eps.size()]; + for(int i = 0; i < eps.size(); i++) { + EigenPair ep = eps.getEigenPair(i); + Vector sev = ep.getEigenvector().times(Math.sqrt(ep.getEigenvalue())); + pc[i] = new Vector(proj.fastProjectRelativeDataToRenderSpace(sev.getArrayRef())); + } + if(drawStyle != 0 || eps.size() == 2) { + drawSphere2D(cnum, cent, pc); + } + else { + Polygon chres = makeHullComplex(pc); + drawHullLines(cnum, cent, chres); + } + } + } + } + + protected void drawSphere2D(int cnum, Vector cent, Vector[] pc) { + for(int dim1 = 0; dim1 < pc.length - 1; dim1++) { + for(int dim2 = dim1 + 1; dim2 < pc.length; dim2++) { + for(int i = 1; i <= times; i++) { + SVGPath path = new SVGPath(); + + Vector direction1 = pc[dim1].times(KAPPA * i); + Vector direction2 = pc[dim2].times(KAPPA * i); + + Vector p1 = cent.plusTimes(pc[dim1], i); + Vector p2 = cent.plusTimes(pc[dim2], i); + Vector p3 = cent.minusTimes(pc[dim1], i); + Vector p4 = cent.minusTimes(pc[dim2], i); + + path.moveTo(p1); + path.cubicTo(p1.plus(direction2), p2.plus(direction1), p2); + path.cubicTo(p2.minus(direction1), p3.plus(direction2), p3); + path.cubicTo(p3.minus(direction2), p4.minus(direction1), p4); + path.cubicTo(p4.plus(direction1), p1.minus(direction2), p1); + path.close(); + + Element ellipse = path.makeElement(svgp); + SVGUtil.addCSSClass(ellipse, EMBORDER + cnum); + if(opacStyle == 1) { + CSSClass cls = new CSSClass(null, "temp"); + double s = (i >= 1 && i <= sigma.length) ? sigma[i - 1] : 0.0; + cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, s); + SVGUtil.setAtt(ellipse, SVGConstants.SVG_STYLE_ATTRIBUTE, cls.inlineCSS()); + } + layer.appendChild(ellipse); + } + } + } + } + + protected void drawHullLines(int cnum, Vector cent, Polygon chres) { + if(chres.size() > 1) { + for(int i = 1; i <= times; i++) { + SVGPath path = new SVGPath(); + for(int p = 0; p < chres.size(); p++) { + Vector cur = cent.plusTimes(chres.get(p), i); + path.drawTo(cur); + } + path.close(); + Element ellipse = path.makeElement(svgp); + SVGUtil.addCSSClass(ellipse, EMBORDER + cnum); + if(opacStyle == 1) { + CSSClass cls = new CSSClass(null, "temp"); + double s = (i >= 1 && i <= sigma.length) ? sigma[i - 1] : 0.0; + cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, s); + SVGUtil.setAtt(ellipse, SVGConstants.SVG_STYLE_ATTRIBUTE, cls.inlineCSS()); + } + layer.appendChild(ellipse); + } + } + } + + protected Polygon makeHull(Vector[] pc) { + GrahamScanConvexHull2D hull = new GrahamScanConvexHull2D(); + + Vector diag = new Vector(0, 0); + for(int j = 0; j < pc.length; j++) { + hull.add(pc[j]); + hull.add(pc[j].times(-1)); + for(int k = j + 1; k < pc.length; k++) { + Vector q = pc[k]; + Vector ppq = pc[j].plus(q).timesEquals(MathUtil.SQRTHALF); + Vector pmq = pc[j].minus(q).timesEquals(MathUtil.SQRTHALF); + hull.add(ppq); + hull.add(ppq.times(-1)); + hull.add(pmq); + hull.add(pmq.times(-1)); + } + diag.plusEquals(pc[j]); + } + diag.timesEquals(1.0 / Math.sqrt(pc.length)); + hull.add(diag); + hull.add(diag.times(-1)); + + Polygon chres = hull.getHull(); + return chres; + } + + protected Polygon makeHullComplex(Vector[] pc) { + GrahamScanConvexHull2D hull = new GrahamScanConvexHull2D(); + + Vector diag = new Vector(0, 0); + for(int j = 0; j < pc.length; j++) { + hull.add(pc[j]); + hull.add(pc[j].times(-1)); + for(int k = j + 1; k < pc.length; k++) { + Vector q = pc[k]; + Vector ppq = pc[j].plus(q).timesEquals(MathUtil.SQRTHALF); + Vector pmq = pc[j].minus(q).timesEquals(MathUtil.SQRTHALF); + hull.add(ppq); + hull.add(ppq.times(-1)); + hull.add(pmq); + hull.add(pmq.times(-1)); + for(int l = k + 1; l < pc.length; l++) { + Vector r = pc[k]; + Vector ppqpr = ppq.plus(r).timesEquals(Math.sqrt(1 / 3.)); + Vector pmqpr = pmq.plus(r).timesEquals(Math.sqrt(1 / 3.)); + Vector ppqmr = ppq.minus(r).timesEquals(Math.sqrt(1 / 3.)); + Vector pmqmr = pmq.minus(r).timesEquals(Math.sqrt(1 / 3.)); + hull.add(ppqpr); + hull.add(ppqpr.times(-1)); + hull.add(pmqpr); + hull.add(pmqpr.times(-1)); + hull.add(ppqmr); + hull.add(ppqmr.times(-1)); + hull.add(pmqmr); + hull.add(pmqmr.times(-1)); + } + } + diag.plusEquals(pc[j]); + } + diag.timesEquals(1.0 / Math.sqrt(pc.length)); + hull.add(diag); + hull.add(diag.times(-1)); + Polygon chres = hull.getHull(); + return chres; + } + + protected void drawHullArc(int cnum, Vector cent, Polygon chres) { + for(int i = 1; i <= times; i++) { + SVGPath path = new SVGPath(); + + ArrayList<Vector> delta = new ArrayList<Vector>(chres.size()); + for(int p = 0; p < chres.size(); p++) { + Vector prev = chres.get((p - 1 + chres.size()) % chres.size()); + Vector curr = chres.get(p); + Vector next = chres.get((p + 1) % chres.size()); + Vector d1 = next.minus(curr).normalize(); + Vector d2 = curr.minus(prev).normalize(); + delta.add(d1.plus(d2)); + // delta.add(next.minus(prev)); + } + + for(int p = 0; p < chres.size(); p++) { + Vector cur = cent.plus(chres.get(p)); + Vector nex = cent.plus(chres.get((p + 1) % chres.size())); + Vector dcur = delta.get(p); + Vector dnex = delta.get((p + 1) % chres.size()); + drawArc(path, cent, cur, nex, dcur, dnex, i); + } + path.close(); + + Element ellipse = path.makeElement(svgp); + + SVGUtil.addCSSClass(ellipse, EMBORDER + cnum); + if(opacStyle == 1) { + CSSClass cls = new CSSClass(null, "temp"); + double s = (i >= 1 && i <= sigma.length) ? sigma[i - 1] : 0.0; + cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, s); + SVGUtil.setAtt(ellipse, SVGConstants.SVG_STYLE_ATTRIBUTE, cls.inlineCSS()); + } + layer.appendChild(ellipse); + } + } + + /** + * Draw an arc to simulate the hyper ellipse. + * + * @param path Path to draw to + * @param cent Center + * @param pre Previous point + * @param nex Next point + * @param scale Scaling factor + */ + private void drawArc(SVGPath path, Vector cent, Vector pre, Vector nex, Vector oPrev, Vector oNext, double scale) { + // Delta vectors + final Vector rPrev = pre.minus(cent); + final Vector rNext = nex.minus(cent); + final Vector rPrNe = pre.minus(nex); + // Scaled fix points + final Vector sPrev = cent.plusTimes(rPrev, scale); + final Vector sNext = cent.plusTimes(rNext, scale); + // Orthogonal vectors to the relative vectors + // final Vector oPrev = new Vector(rPrev.get(1), -rPrev.get(0)); + // final Vector oNext = new Vector(-rNext.get(1), rNext.get(0)); + + // Compute the intersection of rPrev+tp*oPrev and rNext+tn*oNext + // rPrNe == rPrev - rNext + final double zp = rPrNe.get(0) * oNext.get(1) - rPrNe.get(1) * oNext.get(0); + final double zn = rPrNe.get(0) * oPrev.get(1) - rPrNe.get(1) * oPrev.get(0); + final double n = oPrev.get(1) * oNext.get(0) - oPrev.get(0) * oNext.get(1); + if(n == 0) { + LoggingUtil.warning("Parallel?!?"); + path.drawTo(sNext.get(0), sNext.get(1)); + return; + } + final double tp = Math.abs(zp / n); + final double tn = Math.abs(zn / n); + // LoggingUtil.warning("tp: "+tp+" tn: "+tn); + + // Guide points + final Vector gPrev = sPrev.plusTimes(oPrev, KAPPA * scale * tp); + final Vector gNext = sNext.minusTimes(oNext, KAPPA * scale * tn); + + if(!path.isStarted()) { + path.moveTo(sPrev); + } + // path.drawTo(sPrev); + // path.drawTo(gPrev); + // path.drawTo(gNext); + // path.drawTo(sNext)); + // path.moveTo(sPrev); + // if(tp < 0 || tn < 0) { + // path.drawTo(sNext); + // } + // else { + path.cubicTo(gPrev, gNext, sNext); + // } + } + + /** + * Adds the required CSS-Classes + * + * @param svgp SVG-Plot + */ + private void addCSSClasses(SVGPlot svgp) { + if(!svgp.getCSSClassManager().contains(EMBORDER)) { + ColorLibrary colors = context.getStyleLibrary().getColorSet(StyleLibrary.PLOT); + String color; + int clusterID = 0; + + for(@SuppressWarnings("unused") + Cluster<?> cluster : clustering.getAllClusters()) { + CSSClass cls = new CSSClass(this, EMBORDER + clusterID); + cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT) / 2); + + if(clustering.getAllClusters().size() == 1) { + color = "black"; + } + else { + color = colors.getColor(clusterID); + } + if(softBorder == 0) { + cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, color); + } + cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, color); + cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, 0.15); + + svgp.addCSSClassOrLogError(cls); + if(opacStyle == 0) { + break; + } + clusterID++; + } + } + } + + /** + * Visualizer for generating SVG-Elements containing ellipses for first, + * second and third standard deviation + * + * @author Robert Rödler + * + * @apiviz.stereotype factory + * @apiviz.uses EMClusterVisualization oneway - - «create» + * + * @param <NV> Type of the NumberVector being visualized. + */ + public static class Factory<NV extends NumberVector<NV, ?>> extends AbstractVisFactory { + /** + * Constructor + */ + public Factory() { + super(); + } + + @Override + public EMClusterVisualization<NV> makeVisualization(VisualizationTask task) { + return new EMClusterVisualization<NV>(task); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + // Find clusterings we can visualize: + Collection<Clustering<?>> clusterings = ResultUtil.filterResults(result, Clustering.class); + for(Clustering<?> c : clusterings) { + if(c.getAllClusters().size() > 0) { + // Does the cluster have a model with cluster means? + Clustering<MeanModel<NV>> mcls = findMeanModel(c); + if(mcls != null) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, c, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA + 3); + baseResult.getHierarchy().add(c, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } + } + + /** + * Test if the given clustering has a mean model. + * + * @param <NV> Vector type + * @param c Clustering to inspect + * @return the clustering cast to return a mean model, null otherwise. + */ + @SuppressWarnings("unchecked") + private static <NV extends NumberVector<NV, ?>> Clustering<MeanModel<NV>> findMeanModel(Clustering<?> c) { + final Model firstModel = c.getAllClusters().get(0).getModel(); + if(c.getAllClusters().get(0).getModel() instanceof MeanModel<?> && firstModel instanceof EMModel<?>) { + return (Clustering<MeanModel<NV>>) c; + } + return null; + } + } +} diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/VoronoiVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/VoronoiVisualization.java new file mode 100644 index 00000000..37f125d4 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/VoronoiVisualization.java @@ -0,0 +1,298 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster;
+/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+
+import de.lmu.ifi.dbs.elki.data.Cluster;
+import de.lmu.ifi.dbs.elki.data.Clustering;
+import de.lmu.ifi.dbs.elki.data.NumberVector;
+import de.lmu.ifi.dbs.elki.data.model.EMModel;
+import de.lmu.ifi.dbs.elki.data.model.MeanModel;
+import de.lmu.ifi.dbs.elki.data.model.Model;
+import de.lmu.ifi.dbs.elki.math.geometry.SweepHullDelaunay2D;
+import de.lmu.ifi.dbs.elki.math.geometry.SweepHullDelaunay2D.Triangle;
+import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.EnumParameter;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPath;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.svg.VoronoiDraw;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+
+/**
+ * Visualizer drawing Voronoi cells for k-means clusterings.
+ *
+ * See also: {@link de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansLloyd KMeans
+ * clustering}
+ *
+ * @author Robert Rödler
+ * @author Erich Schubert
+ *
+ * @apiviz.has MeanModel oneway - - visualizes
+ */
+public class VoronoiVisualization extends AbstractScatterplotVisualization {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "k-means Voronoi cells";
+
+ /**
+ * Generic tags to indicate the type of element. Used in IDs, CSS-Classes etc.
+ */
+ private static final String KMEANSBORDER = "kmeans-border";
+
+ /**
+ * Visualization mode.
+ *
+ * @author Erich Schubert
+ *
+ * @apiviz.exclude
+ */
+ public static enum Mode {
+ VORONOI, DELAUNAY, V_AND_D
+ }
+
+ /**
+ * The result we work on
+ */
+ Clustering<MeanModel<? extends NumberVector<?, ?>>> clustering;
+
+ /**
+ * The Voronoi diagram
+ */
+ Element voronoi;
+
+ /**
+ * Active drawing mode.
+ */
+ private Mode mode;
+
+ /**
+ * Constructor
+ *
+ * @param task VisualizationTask
+ * @param mode Drawing mode
+ */
+ public VoronoiVisualization(VisualizationTask task, Mode mode) {
+ super(task);
+ this.clustering = task.getResult();
+ this.mode = mode;
+ incrementalRedraw();
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+ final List<Cluster<MeanModel<? extends NumberVector<?, ?>>>> clusters = clustering.getAllClusters();
+
+ if(clusters.size() < 2) {
+ return;
+ }
+
+ // Collect cluster means
+ if(clusters.size() == 2) {
+ ArrayList<double[]> means = new ArrayList<double[]>(clusters.size());
+ {
+ for(Cluster<MeanModel<? extends NumberVector<?, ?>>> clus : clusters) {
+ means.add(clus.getModel().getMean().getColumnVector().getArrayRef());
+ }
+ }
+ if(mode == Mode.VORONOI || mode == Mode.V_AND_D) {
+ Element path = VoronoiDraw.drawFakeVoronoi(proj, means).makeElement(svgp);
+ SVGUtil.addCSSClass(path, KMEANSBORDER);
+ layer.appendChild(path);
+ }
+ if(mode == Mode.DELAUNAY || mode == Mode.V_AND_D) {
+ Element path = new SVGPath(proj.fastProjectDataToRenderSpace(means.get(0))).drawTo(proj.fastProjectDataToRenderSpace(means.get(1))).makeElement(svgp);
+ SVGUtil.addCSSClass(path, KMEANSBORDER);
+ layer.appendChild(path);
+ }
+ }
+ else {
+ ArrayList<Vector> vmeans = new ArrayList<Vector>(clusters.size());
+ ArrayList<double[]> means = new ArrayList<double[]>(clusters.size());
+ {
+ for(Cluster<MeanModel<? extends NumberVector<?, ?>>> clus : clusters) {
+ Vector v = clus.getModel().getMean().getColumnVector();
+ vmeans.add(v);
+ means.add(v.getArrayRef());
+ }
+ }
+ // Compute Delaunay Triangulation
+ ArrayList<Triangle> delaunay = new SweepHullDelaunay2D(vmeans).getDelaunay();
+ if(mode == Mode.VORONOI || mode == Mode.V_AND_D) {
+ Element path = VoronoiDraw.drawVoronoi(proj, delaunay, means).makeElement(svgp);
+ SVGUtil.addCSSClass(path, KMEANSBORDER);
+ layer.appendChild(path);
+ }
+ if(mode == Mode.DELAUNAY || mode == Mode.V_AND_D) {
+ Element path = VoronoiDraw.drawDelaunay(proj, delaunay, means).makeElement(svgp);
+ SVGUtil.addCSSClass(path, KMEANSBORDER);
+ layer.appendChild(path);
+ }
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ private void addCSSClasses(SVGPlot svgp) {
+ // Class for the distance markers
+ if(!svgp.getCSSClassManager().contains(KMEANSBORDER)) {
+ CSSClass cls = new CSSClass(this, KMEANSBORDER);
+ cls = new CSSClass(this, KMEANSBORDER);
+ cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, SVGConstants.CSS_BLACK_VALUE);
+ cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT) * .5);
+ cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_NONE_VALUE);
+ cls.setStatement(SVGConstants.CSS_STROKE_LINECAP_PROPERTY, SVGConstants.CSS_ROUND_VALUE);
+ cls.setStatement(SVGConstants.CSS_STROKE_LINEJOIN_PROPERTY, SVGConstants.CSS_ROUND_VALUE);
+ svgp.addCSSClassOrLogError(cls);
+ }
+ }
+
+ /**
+ * Factory for visualizers to generate an SVG-Element containing the lines
+ * between kMeans clusters
+ *
+ * @author Robert Rödler
+ * @author Erich Schubert
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses VoronoiVisualisation oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Mode for drawing: Voronoi, Delaunay, both
+ *
+ * <p>
+ * Key: {@code -voronoi.mode}
+ * </p>
+ */
+ public static final OptionID MODE_ID = OptionID.getOrCreateOptionID("voronoi.mode", "Mode for drawing the voronoi cells (and/or delaunay triangulation)");
+
+ /**
+ * Drawing mode
+ */
+ private Mode mode;
+
+ /**
+ * Constructor
+ *
+ * @param mode Drawing mode
+ */
+ public Factory(Mode mode) {
+ super();
+ this.mode = mode;
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new VoronoiVisualization(task, mode);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ // Find clusterings we can visualize:
+ Collection<Clustering<?>> clusterings = ResultUtil.filterResults(result, Clustering.class);
+ for(Clustering<?> c : clusterings) {
+ if(c.getAllClusters().size() > 0) {
+ // Does the cluster have a model with cluster means?
+ Clustering<MeanModel<? extends NumberVector<?, ?>>> mcls = findMeanModel(c);
+ if(mcls != null) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ if(DatabaseUtil.dimensionality(p.getRelation()) == 2) {
+ final VisualizationTask task = new VisualizationTask(NAME, c, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA + 3);
+ baseResult.getHierarchy().add(p, task);
+ baseResult.getHierarchy().add(c, task);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Test if the given clustering has a mean model.
+ *
+ * @param c Clustering to inspect
+ * @return the clustering cast to return a mean model, null otherwise.
+ */
+ @SuppressWarnings("unchecked")
+ private static Clustering<MeanModel<? extends NumberVector<?, ?>>> findMeanModel(Clustering<?> c) {
+ final Model firstModel = c.getAllClusters().get(0).getModel();
+ if(firstModel instanceof MeanModel<?> && !(firstModel instanceof EMModel<?>)) {
+ return (Clustering<MeanModel<? extends NumberVector<?, ?>>>) c;
+ }
+ return null;
+ }
+
+ /**
+ * Parameterization class.
+ *
+ * @author Erich Schubert
+ *
+ * @apiviz.exclude
+ */
+ public static class Parameterizer extends AbstractParameterizer {
+ protected Mode mode;
+
+ @Override
+ protected void makeOptions(Parameterization config) {
+ super.makeOptions(config);
+ EnumParameter<Mode> modeP = new EnumParameter<Mode>(MODE_ID, Mode.class, Mode.VORONOI);
+ if(config.grab(modeP)) {
+ mode = modeP.getValue();
+ }
+ }
+
+ @Override
+ protected Factory makeInstance() {
+ return new Factory(mode);
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/package-info.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/package-info.java new file mode 100644 index 00000000..0f232498 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/cluster/package-info.java @@ -0,0 +1,26 @@ +/** + * <p>Visualizers for clustering results based on 2D projections.</p> + */ +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.cluster;
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/density/DensityEstimationOverlay.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/density/DensityEstimationOverlay.java new file mode 100644 index 00000000..28e4da32 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/density/DensityEstimationOverlay.java @@ -0,0 +1,236 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.density; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +import java.awt.image.BufferedImage; +import java.util.Arrays; +import java.util.Comparator; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.math.MathUtil; +import de.lmu.ifi.dbs.elki.math.MeanVariance; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.KMLOutputHandler; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.batikutil.ThumbnailRegistryEntry; +import de.lmu.ifi.dbs.elki.visualization.projections.CanvasSize; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; +import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization; + +/** + * A simple density estimation visualization, based on a simple kernel-density + * <em>in the projection, not the actual data!</em> + * + * @author Erich Schubert + */ +// TODO: make parameterizable, in particular color map, kernel bandwidth and +// kernel function +public class DensityEstimationOverlay extends AbstractScatterplotVisualization { + /** + * A short name characterizing this Visualizer. + */ + private static final String NAME = "Density estimation overlay"; + + /** + * Density map resolution + */ + private int resolution = 500; + + /** + * The actual image + */ + private BufferedImage img = null; + + /** + * Constructor. + * + * @param task Task + */ + public DensityEstimationOverlay(VisualizationTask task) { + super(task); + incrementalRedraw(); + } + + @Override + protected void redraw() { + if(img == null) { + renderImage(); + } + + CanvasSize canvas = proj.estimateViewport(); + String imguri = ThumbnailRegistryEntry.INTERNAL_PREFIX + ThumbnailRegistryEntry.registerImage(img); + Element itag = svgp.svgElement(SVGConstants.SVG_IMAGE_TAG); + SVGUtil.setAtt(itag, SVGConstants.SVG_IMAGE_RENDERING_ATTRIBUTE, SVGConstants.SVG_OPTIMIZE_SPEED_VALUE); + SVGUtil.setAtt(itag, SVGConstants.SVG_X_ATTRIBUTE, canvas.minx); + SVGUtil.setAtt(itag, SVGConstants.SVG_Y_ATTRIBUTE, canvas.miny); + SVGUtil.setAtt(itag, SVGConstants.SVG_WIDTH_ATTRIBUTE, canvas.maxx - canvas.minx); + SVGUtil.setAtt(itag, SVGConstants.SVG_HEIGHT_ATTRIBUTE, canvas.maxy - canvas.miny); + SVGUtil.setAtt(itag, SVGConstants.SVG_STYLE_ATTRIBUTE, SVGConstants.CSS_OPACITY_PROPERTY + ": .5"); + itag.setAttributeNS(SVGConstants.XLINK_NAMESPACE_URI, SVGConstants.XLINK_HREF_QNAME, imguri); + + layer.appendChild(itag); + } + + @Reference(authors = "D. W. Scott", title = "Multivariate density estimation", booktitle = "Multivariate Density Estimation: Theory, Practice, and Visualization", url = "http://dx.doi.org/10.1002/9780470316849.fmatter") + private double[] initializeBandwidth(double[][] data) { + MeanVariance mv0 = new MeanVariance(); + MeanVariance mv1 = new MeanVariance(); + // For Kernel bandwidth. + for(double[] projected : data) { + mv0.put(projected[0]); + mv1.put(projected[1]); + } + // Set bandwidths according to Scott's rule: + // Note: in projected space, d=2. + double[] bandwidth = new double[2]; + bandwidth[0] = MathUtil.SQRT5 * mv0.getSampleStddev() * Math.pow(rel.size(), -1 / 6.); + bandwidth[1] = MathUtil.SQRT5 * mv1.getSampleStddev() * Math.pow(rel.size(), -1 / 6.); + return bandwidth; + } + + private void renderImage() { + // TODO: SAMPLE? Do region queries? + // Project the data just once, keep a copy. + double[][] data = new double[rel.size()][]; + { + int i = 0; + for(DBID id : rel.iterDBIDs()) { + data[i] = proj.fastProjectDataToRenderSpace(rel.get(id)); + i++; + } + } + double[] bandwidth = initializeBandwidth(data); + // Compare by first component + Comparator<double[]> comp0 = new Comparator<double[]>() { + @Override + public int compare(double[] o1, double[] o2) { + return Double.compare(o1[0], o2[0]); + } + }; + // Compare by second component + Comparator<double[]> comp1 = new Comparator<double[]>() { + @Override + public int compare(double[] o1, double[] o2) { + return Double.compare(o1[1], o2[1]); + } + }; + // TODO: choose comparator order based on smaller bandwidth? + Arrays.sort(data, comp0); + + CanvasSize canvas = proj.estimateViewport(); + double min0 = canvas.minx, max0 = canvas.maxx, ste0 = (max0 - min0) / resolution; + double min1 = canvas.miny, max1 = canvas.maxy, ste1 = (max1 - min1) / resolution; + + double kernf = 9. / (16 * bandwidth[0] * bandwidth[1]); + double maxdens = 0.0; + double[][] dens = new double[resolution][resolution]; + { + // TODO: incrementally update the loff/roff values? + for(int x = 0; x < resolution; x++) { + double xlow = min0 + ste0 * x, xhig = xlow + ste0; + int loff = unflip(Arrays.binarySearch(data, new double[] { xlow - bandwidth[0] }, comp0)); + int roff = unflip(Arrays.binarySearch(data, new double[] { xhig + bandwidth[0] }, comp0)); + // Resort by second component + Arrays.sort(data, loff, roff, comp1); + for(int y = 0; y < resolution; y++) { + double ylow = min1 + ste1 * y, yhig = ylow + ste1; + int boff = unflip(Arrays.binarySearch(data, loff, roff, new double[] { 0, ylow - bandwidth[1] }, comp1)); + int toff = unflip(Arrays.binarySearch(data, loff, roff, new double[] { 0, yhig + bandwidth[1] }, comp1)); + for(int pos = boff; pos < toff; pos++) { + double[] val = data[pos]; + double d0 = (val[0] < xlow) ? (xlow - val[0]) : (val[0] > xhig) ? (val[0] - xhig) : 0; + double d1 = (val[1] < ylow) ? (ylow - val[1]) : (val[1] > yhig) ? (val[1] - yhig) : 0; + d0 = d0 / bandwidth[0]; + d1 = d1 / bandwidth[1]; + dens[x][y] += kernf * (1 - d0 * d0) * (1 - d1 * d1); + } + maxdens = Math.max(maxdens, dens[x][y]); + } + // Restore original sorting, as the intervals overlap + Arrays.sort(data, loff, roff, comp0); + } + } + img = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_ARGB); + { + for(int x = 0; x < resolution; x++) { + for(int y = 0; y < resolution; y++) { + int rgb = KMLOutputHandler.getColorForValue(dens[x][y] / maxdens).getRGB(); + img.setRGB(x, y, rgb); + } + } + } + } + + private int unflip(int binarySearch) { + if(binarySearch < 0) { + return (-binarySearch) - 1; + } + else { + return binarySearch; + } + } + + /** + * The visualization factory + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses DensityEstimation2DVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Constructor, adhering to + * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable} + */ + public Factory() { + super(); + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new DensityEstimationOverlay(task); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(result, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, p.getRelation(), p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA + 1); + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + baseResult.getHierarchy().add(p, task); + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/density/package-info.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/density/package-info.java new file mode 100644 index 00000000..b9771aed --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/density/package-info.java @@ -0,0 +1,26 @@ +/** + * <p>Visualizers for data set density in a scatterplot projection.</p> + */ +/* +This file is part of ELKI: +Environment for Developing KDD-Applications Supported by Index-Structures + +Copyright (C) 2012 +Ludwig-Maximilians-Universität München +Lehr- und Forschungseinheit für Datenbanksysteme +ELKI Development Team + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU Affero General Public License as published by +the Free Software Foundation, either version 3 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 Affero General Public License for more details. + +You should have received a copy of the GNU Affero General Public License +along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.density;
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/TreeMBRVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/TreeMBRVisualization.java new file mode 100644 index 00000000..0b4bee2f --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/TreeMBRVisualization.java @@ -0,0 +1,256 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.index; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.ArrayList; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; +import de.lmu.ifi.dbs.elki.data.spatial.SpatialUtil; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener; +import de.lmu.ifi.dbs.elki.index.tree.spatial.SpatialEntry; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTree; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTreeNode; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rstar.RStarTreeNode; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.colors.ColorLibrary; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projections.Projection2D; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGHyperCube; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; +import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization; + +/** + * Visualize the bounding rectangles of an R-Tree based index. + * + * @author Erich Schubert + * + * @apiviz.has AbstractRStarTree oneway - - visualizes + * @apiviz.uses SVGHyperCube + * + * @param <N> Tree node type + * @param <E> Tree entry type + */ +// TODO: listen for tree changes instead of data changes? +public class TreeMBRVisualization<N extends AbstractRStarTreeNode<N, E>, E extends SpatialEntry> extends AbstractScatterplotVisualization implements DataStoreListener { + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String INDEX = "index"; + + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME = "Index MBRs"; + + /** + * Fill parameter. + */ + protected boolean fill = false; + + /** + * The tree we visualize + */ + protected AbstractRStarTree<N, E> tree; + + /** + * Constructor. + * + * @param task Visualization task + * @param fill Fill flag + */ + @SuppressWarnings("unchecked") + public TreeMBRVisualization(VisualizationTask task, boolean fill) { + super(task); + this.tree = AbstractRStarTree.class.cast(task.getResult()); + this.fill = fill; + incrementalRedraw(); + context.addDataStoreListener(this); + } + + @Override + protected void redraw() { + int projdim = proj.getVisibleDimensions2D().cardinality(); + ColorLibrary colors = context.getStyleLibrary().getColorSet(StyleLibrary.PLOT); + + if(tree != null) { + E root = tree.getRootEntry(); + for(int i = 0; i < tree.getHeight(); i++) { + CSSClass cls = new CSSClass(this, INDEX + i); + // Relative depth of this level. 1.0 = toplevel + final double relDepth = 1. - (((double) i) / tree.getHeight()); + if(fill) { + cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, colors.getColor(i)); + cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, relDepth * context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT)); + cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, colors.getColor(i)); + cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, 0.1 / (projdim - 1)); + } + else { + cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, colors.getColor(i)); + cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, relDepth * context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT)); + cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_NONE_VALUE); + } + cls.setStatement(SVGConstants.CSS_STROKE_LINECAP_PROPERTY, SVGConstants.CSS_ROUND_VALUE); + cls.setStatement(SVGConstants.CSS_STROKE_LINEJOIN_PROPERTY, SVGConstants.CSS_ROUND_VALUE); + svgp.addCSSClassOrLogError(cls); + } + visualizeRTreeEntry(svgp, layer, proj, tree, root, 0); + } + } + + /** + * Recursively draw the MBR rectangles. + * + * @param svgp SVG Plot + * @param layer Layer + * @param proj Projection + * @param rtree Rtree to visualize + * @param entry Current entry + * @param depth Current depth + */ + private void visualizeRTreeEntry(SVGPlot svgp, Element layer, Projection2D proj, AbstractRStarTree<? extends N, E> rtree, E entry, int depth) { + SpatialComparable mbr = entry; + + if(fill) { + Element r = SVGHyperCube.drawFilled(svgp, INDEX + depth, proj, SpatialUtil.getMin(mbr), SpatialUtil.getMax(mbr)); + layer.appendChild(r); + } + else { + Element r = SVGHyperCube.drawFrame(svgp, proj, SpatialUtil.getMin(mbr), SpatialUtil.getMax(mbr)); + SVGUtil.setCSSClass(r, INDEX + depth); + layer.appendChild(r); + } + + if(!entry.isLeafEntry()) { + N node = rtree.getNode(entry); + for(int i = 0; i < node.getNumEntries(); i++) { + E child = node.getEntry(i); + if(!child.isLeafEntry()) { + visualizeRTreeEntry(svgp, layer, proj, rtree, child, depth + 1); + } + } + } + } + + @Override + public void destroy() { + super.destroy(); + context.removeDataStoreListener(this); + } + + /** + * Factory + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses TreeMBRVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Flag for half-transparent filling of bubbles. + * + * <p> + * Key: {@code -index.fill} + * </p> + */ + public static final OptionID FILL_ID = OptionID.getOrCreateOptionID("index.fill", "Partially transparent filling of index pages."); + + /** + * Fill parameter. + */ + protected boolean fill = false; + + /** + * Constructor. + * + * @param fill + */ + public Factory(boolean fill) { + super(); + this.fill = fill; + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new TreeMBRVisualization<RStarTreeNode, SpatialEntry>(task, fill); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + ArrayList<AbstractRStarTree<RStarTreeNode, SpatialEntry>> trees = ResultUtil.filterResults(result, AbstractRStarTree.class); + for(AbstractRStarTree<RStarTreeNode, SpatialEntry> tree : trees) { + if(tree instanceof Result) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, (Result) tree, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_BACKGROUND + 1); + baseResult.getHierarchy().add((Result) tree, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } + + /** + * Parameterization class. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class Parameterizer extends AbstractParameterizer { + protected boolean fill = false; + + @Override + protected void makeOptions(Parameterization config) { + super.makeOptions(config); + Flag fillF = new Flag(FILL_ID); + if(config.grab(fillF)) { + fill = fillF.getValue(); + } + } + + @Override + protected Factory makeInstance() { + return new Factory(fill); + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/TreeSphereVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/TreeSphereVisualization.java new file mode 100644 index 00000000..85429eb1 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/TreeSphereVisualization.java @@ -0,0 +1,318 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.index; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.ArrayList; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancefunction.EuclideanDistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancefunction.LPNormDistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancefunction.ManhattanDistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancevalue.DoubleDistance; +import de.lmu.ifi.dbs.elki.distance.distancevalue.NumberDistance; +import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTree; +import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTreeNode; +import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; +import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mtree.MTreeNode; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.colors.ColorLibrary; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projections.Projection2D; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGHyperSphere; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; +import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization; + +/** + * Visualize the bounding sphere of a metric index. + * + * @author Erich Schubert + * + * @apiviz.has AbstractMTree oneway - - visualizes + * @apiviz.uses SVGHyperSphere + * + * @param <N> Tree node type + * @param <E> Tree entry type + */ +// TODO: listen for tree changes! +public class TreeSphereVisualization<D extends NumberDistance<D, ?>, N extends AbstractMTreeNode<?, D, N, E>, E extends MTreeEntry<D>> extends AbstractScatterplotVisualization implements DataStoreListener { + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String INDEX = "index"; + + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME = "Index Spheres"; + + /** + * Drawing modes. + * + * @apiviz.exclude + */ + private enum Modus { + MANHATTAN, EUCLIDEAN, LPCROSS + } + + protected double p; + + /** + * Drawing mode (distance) to use + */ + protected Modus dist = Modus.LPCROSS; + + /** + * The tree we visualize + */ + protected AbstractMTree<?, D, N, E> tree; + + /** + * Fill parameter. + */ + protected boolean fill = false; + + /** + * Constructor + * + * @param task Task + * @param fill fill flag + */ + @SuppressWarnings("unchecked") + public TreeSphereVisualization(VisualizationTask task, boolean fill) { + super(task); + this.tree = AbstractMTree.class.cast(task.getResult()); + this.p = getLPNormP(this.tree); + this.fill = fill; + incrementalRedraw(); + context.addDataStoreListener(this); + } + + /** + * Get the "p" value of an Lp norm. + * + * @param tree Tree to visualize + * @return p value + */ + public static Double getLPNormP(AbstractMTree<?, ?, ?, ?> tree) { + // Note: we deliberately lose generics here, so the compilers complain less + // on the next typecheck and cast! + DistanceFunction<?, ?> distanceFunction = tree.getDistanceQuery().getDistanceFunction(); + if(LPNormDistanceFunction.class.isInstance(distanceFunction)) { + return ((LPNormDistanceFunction) distanceFunction).getP(); + } + return null; + } + + /** + * Test for a visualizable index in the context's database. + * + * @param tree Tree to visualize + * @return whether the tree is visualizable + */ + public static boolean canVisualize(AbstractMTree<?, ?, ?, ?> tree) { + Double p = getLPNormP(tree); + return (p != null); + } + + @Override + protected void redraw() { + int projdim = proj.getVisibleDimensions2D().cardinality(); + ColorLibrary colors = context.getStyleLibrary().getColorSet(StyleLibrary.PLOT); + + p = getLPNormP(tree); + if(tree != null) { + if(ManhattanDistanceFunction.class.isInstance(tree.getDistanceQuery())) { + dist = Modus.MANHATTAN; + } + else if(EuclideanDistanceFunction.class.isInstance(tree.getDistanceQuery())) { + dist = Modus.EUCLIDEAN; + } + else { + dist = Modus.LPCROSS; + } + E root = tree.getRootEntry(); + final int mtheight = tree.getHeight(); + for(int i = 0; i < mtheight; i++) { + CSSClass cls = new CSSClass(this, INDEX + i); + // Relative depth of this level. 1.0 = toplevel + final double relDepth = 1. - (((double) i) / mtheight); + if(fill) { + cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, colors.getColor(i)); + cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, relDepth * context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT)); + cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, colors.getColor(i)); + cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, 0.1 / (projdim - 1)); + cls.setStatement(SVGConstants.CSS_STROKE_LINECAP_PROPERTY, SVGConstants.CSS_ROUND_VALUE); + cls.setStatement(SVGConstants.CSS_STROKE_LINEJOIN_PROPERTY, SVGConstants.CSS_ROUND_VALUE); + } + else { + cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, colors.getColor(i)); + cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, relDepth * context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT)); + cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_NONE_VALUE); + cls.setStatement(SVGConstants.CSS_STROKE_LINECAP_PROPERTY, SVGConstants.CSS_ROUND_VALUE); + cls.setStatement(SVGConstants.CSS_STROKE_LINEJOIN_PROPERTY, SVGConstants.CSS_ROUND_VALUE); + } + svgp.addCSSClassOrLogError(cls); + } + visualizeMTreeEntry(svgp, this.layer, proj, tree, root, 0); + } + } + + /** + * Recursively draw the MBR rectangles. + * + * @param svgp SVG Plot + * @param layer Layer + * @param proj Projection + * @param mtree Mtree to visualize + * @param entry Current entry + * @param depth Current depth + */ + private void visualizeMTreeEntry(SVGPlot svgp, Element layer, Projection2D proj, AbstractMTree<?, D, N, E> mtree, E entry, int depth) { + DBID roid = entry.getRoutingObjectID(); + if(roid != null) { + NumberVector<?, ?> ro = rel.get(roid); + D rad = entry.getCoveringRadius(); + + final Element r; + if(dist == Modus.MANHATTAN) { + r = SVGHyperSphere.drawManhattan(svgp, proj, ro, rad); + } + else if(dist == Modus.EUCLIDEAN) { + r = SVGHyperSphere.drawEuclidean(svgp, proj, ro, rad); + } + // TODO: add visualizer for infinity norm? + else { + // r = SVGHyperSphere.drawCross(svgp, proj, ro, rad); + r = SVGHyperSphere.drawLp(svgp, proj, ro, rad, p); + } + SVGUtil.setCSSClass(r, INDEX + (depth - 1)); + layer.appendChild(r); + } + + if(!entry.isLeafEntry()) { + N node = mtree.getNode(entry); + for(int i = 0; i < node.getNumEntries(); i++) { + E child = node.getEntry(i); + if(!child.isLeafEntry()) { + visualizeMTreeEntry(svgp, layer, proj, mtree, child, depth + 1); + } + } + } + } + + @Override + public void destroy() { + super.destroy(); + context.removeDataStoreListener(this); + } + + /** + * Factory + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses TreeSphereVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Fill parameter. + */ + protected boolean fill = false; + + /** + * Constructor. + * + * @param fill + */ + public Factory(boolean fill) { + super(); + this.fill = fill; + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + for(ScatterPlotProjector<?> p : ps) { + ArrayList<AbstractMTree<?, DoubleDistance, ?, ?>> trees = ResultUtil.filterResults(result, AbstractMTree.class); + for(AbstractMTree<?, DoubleDistance, ?, ?> tree : trees) { + if(canVisualize(tree) && tree instanceof Result) { + final VisualizationTask task = new VisualizationTask(NAME, (Result) tree, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_BACKGROUND + 1); + baseResult.getHierarchy().add((Result) tree, task); + baseResult.getHierarchy().add(p, task); + } + } + } + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + return new TreeSphereVisualization<DoubleDistance, MTreeNode<Object, DoubleDistance>, MTreeEntry<DoubleDistance>>(task, fill); + } + + /** + * Parameterization class. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class Parameterizer extends AbstractParameterizer { + protected boolean fill = false; + + @Override + protected void makeOptions(Parameterization config) { + super.makeOptions(config); + Flag fillF = new Flag(TreeMBRVisualization.Factory.FILL_ID); + if(config.grab(fillF)) { + fill = fillF.getValue(); + } + } + + @Override + protected Factory makeInstance() { + return new Factory(fill); + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/package-info.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/package-info.java new file mode 100644 index 00000000..a4b3c0c9 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/index/package-info.java @@ -0,0 +1,26 @@ +/** + * <p>Visualizers for index structures based on 2D projections.</p> + */ +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.index;
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/outlier/BubbleVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/outlier/BubbleVisualization.java new file mode 100644 index 00000000..7c40c1cb --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/outlier/BubbleVisualization.java @@ -0,0 +1,345 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.outlier; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.List; + +import org.apache.batik.util.SVGConstants; +import org.w3c.dom.Element; + +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener; +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.result.HierarchicalResult; +import de.lmu.ifi.dbs.elki.result.Result; +import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; +import de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction; +import de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierScalingFunction; +import de.lmu.ifi.dbs.elki.visualization.VisualizationTask; +import de.lmu.ifi.dbs.elki.visualization.colors.ColorLibrary; +import de.lmu.ifi.dbs.elki.visualization.css.CSSClass; +import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector; +import de.lmu.ifi.dbs.elki.visualization.style.ClassStylingPolicy; +import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary; +import de.lmu.ifi.dbs.elki.visualization.style.StylingPolicy; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot; +import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil; +import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory; +import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization; +import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization; + +/** + * Generates a SVG-Element containing bubbles. A Bubble is a circle visualizing + * an outlierness-score, with its center at the position of the visualized + * object and its radius depending on the objects score. + * + * @author Remigius Wojdanowski + * @author Erich Schubert + * + * @apiviz.has OutlierResult oneway - - visualizes + */ +@Reference(authors = "E. Achtert, H.-P. Kriegel, L. Reichert, E. Schubert, R. Wojdanowski, A. Zimek", title = "Visual Evaluation of Outlier Detection Models", booktitle = "Proceedings of the 15th International Conference on Database Systems for Advanced Applications (DASFAA), Tsukuba, Japan, 2010", url = "http://dx.doi.org/10.1007/978-3-642-12098-5_34") +public class BubbleVisualization extends AbstractScatterplotVisualization implements DataStoreListener { + /** + * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc. + */ + public static final String BUBBLE = "bubble"; + + /** + * A short name characterizing this Visualizer. + */ + public static final String NAME = "Outlier Bubbles"; + + /** + * Fill parameter. + */ + protected boolean fill; + + /** + * Scaling function to use for Bubbles + */ + protected ScalingFunction scaling; + + /** + * The outlier result to visualize + */ + protected OutlierResult result; + + /** + * Constructor. + * + * @param task Visualization task + * @param scaling Scaling function + */ + public BubbleVisualization(VisualizationTask task, ScalingFunction scaling) { + super(task); + this.result = task.getResult(); + this.scaling = scaling; + context.addDataStoreListener(this); + incrementalRedraw(); + } + + @Override + public void destroy() { + super.destroy(); + context.removeDataStoreListener(this); + } + + @Override + public void redraw() { + StylingPolicy stylepolicy = context.getStyleResult().getStylingPolicy(); + // bubble size + final double bubble_size = context.getStyleLibrary().getSize(StyleLibrary.BUBBLEPLOT); + if(stylepolicy instanceof ClassStylingPolicy) { + ClassStylingPolicy colors = (ClassStylingPolicy) stylepolicy; + setupCSS(svgp, colors); + // draw data + for(DBID objId : sample.getSample()) { + final Double radius = getScaledForId(objId); + if(radius > 0.01 && !Double.isInfinite(radius)) { + final NumberVector<?, ?> vec = rel.get(objId); + if(vec != null) { + double[] v = proj.fastProjectDataToRenderSpace(vec); + Element circle = svgp.svgCircle(v[0], v[1], radius * bubble_size); + SVGUtil.addCSSClass(circle, BUBBLE + colors.getStyleForDBID(objId)); + layer.appendChild(circle); + } + } + } + } + else { + // draw data + for(DBID objId : sample.getSample()) { + final Double radius = getScaledForId(objId); + if(radius > 0.01 && !Double.isInfinite(radius)) { + final NumberVector<?, ?> vec = rel.get(objId); + if(vec != null) { + double[] v = proj.fastProjectDataToRenderSpace(vec); + Element circle = svgp.svgCircle(v[0], v[1], radius * bubble_size); + int color = stylepolicy.getColorForDBID(objId); + final StringBuffer style = new StringBuffer(); + if(fill) { + style.append(SVGConstants.CSS_FILL_PROPERTY + ":").append(SVGUtil.colorToString(color)); + style.append(SVGConstants.CSS_FILL_OPACITY_PROPERTY + ":0.5"); + } + else { + style.append(SVGConstants.CSS_STROKE_VALUE + ":").append(SVGUtil.colorToString(color)); + style.append(SVGConstants.CSS_FILL_PROPERTY + ":" + SVGConstants.CSS_NONE_VALUE); + } + SVGUtil.setAtt(circle, SVGConstants.SVG_STYLE_ATTRIBUTE, style.toString()); + layer.appendChild(circle); + } + } + } + } + } + + @Override + public void resultChanged(Result current) { + if(sample == current) { + synchronizedRedraw(); + } + } + + /** + * Registers the Bubble-CSS-Class at a SVGPlot. + * + * @param svgp the SVGPlot to register the Tooltip-CSS-Class. + * @param policy Clustering to use + */ + private void setupCSS(SVGPlot svgp, ClassStylingPolicy policy) { + ColorLibrary colors = context.getStyleLibrary().getColorSet(StyleLibrary.PLOT); + + // creating IDs manually because cluster often return a null-ID. + for(int clusterID = policy.getMinStyle(); clusterID < policy.getMaxStyle(); clusterID++) { + CSSClass bubble = new CSSClass(svgp, BUBBLE + clusterID); + bubble.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.PLOT)); + + String color = colors.getColor(clusterID); + + if(fill) { + bubble.setStatement(SVGConstants.CSS_FILL_PROPERTY, color); + bubble.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, 0.5); + } + else { + // for diamond-shaped strokes, see bugs.sun.com, bug ID 6294396 + bubble.setStatement(SVGConstants.CSS_STROKE_VALUE, color); + bubble.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_NONE_VALUE); + } + + svgp.addCSSClassOrLogError(bubble); + } + } + + /** + * Convenience method to apply scalings in the right order. + * + * @param id object ID to get scaled score for + * @return a Double representing a outlierness-score, after it has modified by + * the given scales. + */ + protected double getScaledForId(DBID id) { + double d = result.getScores().get(id).doubleValue(); + if(Double.isNaN(d) || Double.isInfinite(d)) { + return 0.0; + } + if(scaling == null) { + return result.getOutlierMeta().normalizeScore(d); + } + else { + return scaling.getScaled(d); + } + } + + /** + * Factory for producing bubble visualizations + * + * @author Erich Schubert + * + * @apiviz.stereotype factory + * @apiviz.uses BubbleVisualization oneway - - «create» + */ + public static class Factory extends AbstractVisFactory { + /** + * Flag for half-transparent filling of bubbles. + * + * <p> + * Key: {@code -bubble.fill} + * </p> + */ + public static final OptionID FILL_ID = OptionID.getOrCreateOptionID("bubble.fill", "Half-transparent filling of bubbles."); + + /** + * Parameter for scaling functions + * + * <p> + * Key: {@code -bubble.scaling} + * </p> + */ + public static final OptionID SCALING_ID = OptionID.getOrCreateOptionID("bubble.scaling", "Additional scaling function for bubbles."); + + /** + * Fill parameter. + */ + protected boolean fill; + + /** + * Scaling function to use for Bubbles + */ + protected ScalingFunction scaling; + + /** + * Constructor. + * + * @param fill + * @param scaling + */ + public Factory(boolean fill, ScalingFunction scaling) { + super(); + this.fill = fill; + this.scaling = scaling; + } + + @Override + public Visualization makeVisualization(VisualizationTask task) { + if(this.scaling != null && this.scaling instanceof OutlierScalingFunction) { + final OutlierResult outlierResult = task.getResult(); + ((OutlierScalingFunction) this.scaling).prepare(outlierResult); + } + return new BubbleVisualization(task, scaling); + } + + @Override + public void processNewResult(HierarchicalResult baseResult, Result result) { + List<OutlierResult> ors = ResultUtil.filterResults(result, OutlierResult.class); + for(OutlierResult o : ors) { + IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class); + boolean vis = true; + // Quick and dirty hack: hide if parent result is also an outlier result + // Since that probably is already visible and we're redundant. + for(Result r : o.getHierarchy().getParents(o)) { + if(r instanceof OutlierResult) { + vis = false; + break; + } + } + for(ScatterPlotProjector<?> p : ps) { + final VisualizationTask task = new VisualizationTask(NAME, o, p.getRelation(), this); + task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA); + if(!vis) { + task.put(VisualizationTask.META_VISIBLE_DEFAULT, false); + } + baseResult.getHierarchy().add(o, task); + baseResult.getHierarchy().add(p, task); + } + } + } + + /** + * Parameterization class. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class Parameterizer extends AbstractParameterizer { + /** + * Fill parameter. + */ + protected boolean fill = false; + + /** + * Scaling function to use for Bubbles + */ + protected ScalingFunction scaling = null; + + @Override + protected void makeOptions(Parameterization config) { + super.makeOptions(config); + Flag fillF = new Flag(FILL_ID); + if(config.grab(fillF)) { + fill = fillF.getValue(); + } + + ObjectParameter<ScalingFunction> scalingP = new ObjectParameter<ScalingFunction>(SCALING_ID, OutlierScalingFunction.class, true); + if(config.grab(scalingP)) { + scaling = scalingP.instantiateClass(config); + } + } + + @Override + protected Factory makeInstance() { + return new Factory(fill, scaling); + } + } + } +}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/outlier/package-info.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/outlier/package-info.java new file mode 100644 index 00000000..7332fcb0 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/outlier/package-info.java @@ -0,0 +1,26 @@ +/** + * <p>Visualizers for outlier scores based on 2D projections.</p> + */ +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.outlier;
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/package-info.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/package-info.java new file mode 100644 index 00000000..805379d7 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/package-info.java @@ -0,0 +1,33 @@ +/** + * <p>Visualizers based on scatterplots.</p> + * + * @apiviz.exclude de.lmu.ifi.dbs.elki.visualization.batikutil.* + * @apiviz.exclude de.lmu.ifi.dbs.elki.visualization.svg.* + * @apiviz.exclude de.lmu.ifi.dbs.elki.result.* + * @apiviz.exclude de.lmu.ifi.dbs.elki.index.* + * @apiviz.exclude de.lmu.ifi.dbs.elki.data.* + * @apiviz.exclude de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener + */ +/* +This file is part of ELKI: +Environment for Developing KDD-Applications Supported by Index-Structures + +Copyright (C) 2012 +Ludwig-Maximilians-Universität München +Lehr- und Forschungseinheit für Datenbanksysteme +ELKI Development Team + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU Affero General Public License as published by +the Free Software Foundation, either version 3 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 Affero General Public License for more details. + +You should have received a copy of the GNU Affero General Public License +along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot;
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/MoveObjectsToolVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/MoveObjectsToolVisualization.java new file mode 100644 index 00000000..fb9de7d5 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/MoveObjectsToolVisualization.java @@ -0,0 +1,228 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2011
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.Iterator;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+import org.w3c.dom.events.Event;
+import org.w3c.dom.svg.SVGPoint;
+
+import de.lmu.ifi.dbs.elki.database.UpdatableDatabase;
+import de.lmu.ifi.dbs.elki.database.ids.DBIDs;
+import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.batikutil.DragableArea;
+import de.lmu.ifi.dbs.elki.visualization.batikutil.DragableArea.DragListener;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+
+/**
+ * Tool to move the currently selected objects.
+ *
+ * @author Heidi Kolb
+ * @author Erich Schubert
+ *
+ * @apiviz.has NumberVector oneway - - edits
+ */
+public class MoveObjectsToolVisualization extends AbstractScatterplotVisualization implements DragListener {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Move Objects";
+
+ /**
+ * CSS tag for our event rectangle
+ */
+ protected static final String CSS_ARROW = "moveArrow";
+
+ /**
+ * Element for the rectangle to add listeners
+ */
+ private Element etag;
+
+ /**
+ * Element to contain the drag arrow
+ */
+ private Element rtag;
+
+ public MoveObjectsToolVisualization(VisualizationTask task) {
+ super(task);
+ incrementalRedraw();
+ }
+
+ @Override
+ public void resultChanged(Result current) {
+ if(sample == current) {
+ synchronizedRedraw();
+ }
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+
+ rtag = svgp.svgElement(SVGConstants.SVG_G_TAG);
+ SVGUtil.addCSSClass(rtag, CSS_ARROW);
+ layer.appendChild(rtag);
+
+ DragableArea drag = new DragableArea(svgp, -0.6 * StyleLibrary.SCALE, -0.7 * StyleLibrary.SCALE, 1.3 * StyleLibrary.SCALE, 1.4 * StyleLibrary.SCALE, this);
+ etag = drag.getElement();
+ layer.appendChild(etag);
+ }
+
+ /**
+ * Updates the objects with the given DBIDs It will be moved depending on the
+ * given Vector
+ *
+ * @param dbids - DBIDs of the objects to move
+ * @param movingVector - Vector for moving object
+ */
+ // TODO: move to DatabaseUtil?
+ private void updateDB(DBIDs dbids, Vector movingVector) {
+ throw new AbortException("FIXME: INCOMPLETE TRANSITION");
+ /*
+ * database.accumulateDataStoreEvents();
+ * Representation<DatabaseObjectMetadata> mrep =
+ * database.getMetadataQuery(); for(DBID dbid : dbids) { NV obj =
+ * database.get(dbid); // Copy metadata to keep DatabaseObjectMetadata meta
+ * = mrep.get(dbid);
+ *
+ * Vector v = proj.projectDataToRenderSpace(obj); v.set(0, v.get(0) +
+ * movingVector.get(0)); v.set(1, v.get(1) + movingVector.get(1)); NV nv =
+ * proj.projectRenderToDataSpace(v, obj); nv.setID(obj.getID());
+ *
+ * try { database.delete(dbid); database.insert(new Pair<NV,
+ * DatabaseObjectMetadata>(nv, meta)); } catch(UnableToComplyException e) {
+ * de.lmu.ifi.dbs.elki.logging.LoggingUtil.exception(e); } }
+ * database.flushDataStoreEvents();
+ */
+ }
+
+ /**
+ * Delete the children of the element
+ *
+ * @param container SVG-Element
+ */
+ private void deleteChildren(Element container) {
+ while(container.hasChildNodes()) {
+ container.removeChild(container.getLastChild());
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVGPlot
+ */
+ private void addCSSClasses(SVGPlot svgp) {
+ // Class for the rectangle to add eventListeners
+ if(!svgp.getCSSClassManager().contains(CSS_ARROW)) {
+ final CSSClass acls = new CSSClass(this, CSS_ARROW);
+ final StyleLibrary style = context.getStyleLibrary();
+ acls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, style.getColor(StyleLibrary.SELECTION_ACTIVE));
+ acls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, style.getLineWidth(StyleLibrary.SELECTION_ACTIVE));
+ acls.setStatement(SVGConstants.CSS_STROKE_LINECAP_PROPERTY, SVGConstants.CSS_ROUND_VALUE);
+ svgp.addCSSClassOrLogError(acls);
+ }
+ }
+
+ @Override
+ public boolean startDrag(SVGPoint startPoint, Event evt) {
+ return true;
+ }
+
+ @Override
+ public boolean duringDrag(SVGPoint startPoint, SVGPoint dragPoint, Event evt, boolean inside) {
+ deleteChildren(rtag);
+ rtag.appendChild(svgp.svgLine(startPoint.getX(), startPoint.getY(), dragPoint.getX(), dragPoint.getY()));
+ return true;
+ }
+
+ @Override
+ public boolean endDrag(SVGPoint startPoint, SVGPoint dragPoint, Event evt, boolean inside) {
+ Vector movingVector = new Vector(2);
+ movingVector.set(0, dragPoint.getX() - startPoint.getX());
+ movingVector.set(1, dragPoint.getY() - startPoint.getY());
+ if(context.getSelection() != null) {
+ updateDB(context.getSelection().getSelectedIds(), movingVector);
+ }
+ deleteChildren(rtag);
+ return true;
+ }
+
+ /**
+ * Factory for tool visualizations for changing objects in the database
+ *
+ * @author Heidi Kolb
+ * @author Erich Schubert
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses MoveObjectsToolVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Constructor
+ */
+ public Factory() {
+ super();
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new MoveObjectsToolVisualization(task);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ Iterator<UpdatableDatabase> dbs = ResultUtil.filteredResults(result, UpdatableDatabase.class);
+ if(!dbs.hasNext()) {
+ return;
+ }
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, p.getRelation(), p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_INTERACTIVE);
+ task.put(VisualizationTask.META_TOOL, true);
+ task.put(VisualizationTask.META_NOTHUMB, true);
+ task.put(VisualizationTask.META_NOEXPORT, true);
+ task.put(VisualizationTask.META_VISIBLE_DEFAULT, false);
+ // baseResult.getHierarchy().add(p.getRelation(), task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionConvexHullVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionConvexHullVisualization.java new file mode 100644 index 00000000..5702800d --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionConvexHullVisualization.java @@ -0,0 +1,173 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2011
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.ArrayList;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+
+import de.lmu.ifi.dbs.elki.data.spatial.Polygon;
+import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener;
+import de.lmu.ifi.dbs.elki.database.ids.DBID;
+import de.lmu.ifi.dbs.elki.database.ids.DBIDs;
+import de.lmu.ifi.dbs.elki.math.geometry.GrahamScanConvexHull2D;
+import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector;
+import de.lmu.ifi.dbs.elki.result.DBIDSelection;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.result.SelectionResult;
+import de.lmu.ifi.dbs.elki.utilities.exceptions.ObjectNotFoundException;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPath;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.thumbs.ThumbnailVisualization;
+
+/**
+ * Visualizer for generating an SVG-Element containing the convex hull of the
+ * selected points
+ *
+ * @author Robert Rödler
+ *
+ * @apiviz.has SelectionResult oneway - - visualizes
+ * @apiviz.has DBIDSelection oneway - - visualizes
+ * @apiviz.uses ConvexHull2D
+ */
+public class SelectionConvexHullVisualization extends AbstractScatterplotVisualization implements DataStoreListener {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Convex Hull of Selection";
+
+ /**
+ * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc.
+ */
+ public static final String SELECTEDHULL = "selectionConvexHull";
+
+ /**
+ * Constructor.
+ *
+ * @param task Task
+ */
+ public SelectionConvexHullVisualization(VisualizationTask task) {
+ super(task);
+ context.addResultListener(this);
+ context.addDataStoreListener(this);
+ incrementalRedraw();
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+ DBIDSelection selContext = context.getSelection();
+ if(selContext != null) {
+ DBIDs selection = selContext.getSelectedIds();
+ GrahamScanConvexHull2D hull = new GrahamScanConvexHull2D();
+ for(DBID i : selection) {
+ try {
+ hull.add(new Vector(proj.fastProjectDataToRenderSpace(rel.get(i))));
+ }
+ catch(ObjectNotFoundException e) {
+ // ignore
+ }
+ }
+ Polygon chres = hull.getHull();
+ if(chres != null && chres.size() >= 3) {
+ SVGPath path = new SVGPath(chres);
+
+ Element selHull = path.makeElement(svgp);
+ SVGUtil.addCSSClass(selHull, SELECTEDHULL);
+ // TODO: use relative selection size for opacity?
+ layer.appendChild(selHull);
+ }
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ private void addCSSClasses(SVGPlot svgp) {
+ // Class for the dot markers
+ if(!svgp.getCSSClassManager().contains(SELECTEDHULL)) {
+ CSSClass cls = new CSSClass(this, SELECTEDHULL);
+ // cls = new CSSClass(this, CONVEXHULL);
+ cls.setStatement(SVGConstants.CSS_STROKE_PROPERTY, context.getStyleLibrary().getColor(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, context.getStyleLibrary().getLineWidth(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, context.getStyleLibrary().getColor(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, ".25");
+ cls.setStatement(SVGConstants.CSS_STROKE_LINECAP_PROPERTY, SVGConstants.CSS_ROUND_VALUE);
+ cls.setStatement(SVGConstants.CSS_STROKE_LINEJOIN_PROPERTY, SVGConstants.CSS_ROUND_VALUE);
+ svgp.addCSSClassOrLogError(cls);
+ }
+ }
+
+ /**
+ * Factory for visualizers to generate an SVG-Element containing the convex
+ * hull of the selected points
+ *
+ * @author Robert Rödler
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses SelectionConvexHullVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Constructor
+ */
+ public Factory() {
+ super();
+ thumbmask |= ThumbnailVisualization.ON_DATA | ThumbnailVisualization.ON_SELECTION;
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new SelectionConvexHullVisualization(task);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ final ArrayList<SelectionResult> selectionResults = ResultUtil.filterResults(result, SelectionResult.class);
+ for(SelectionResult selres : selectionResults) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, selres, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA - 2);
+ baseResult.getHierarchy().add(selres, task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionCubeVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionCubeVisualization.java new file mode 100644 index 00000000..9fd24b43 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionCubeVisualization.java @@ -0,0 +1,267 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2012
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.ArrayList;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+
+import de.lmu.ifi.dbs.elki.result.DBIDSelection;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.RangeSelection;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.result.SelectionResult;
+import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag;
+import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleDoublePair;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projections.Projection2D;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGHyperCube;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.thumbs.ThumbnailVisualization;
+
+/**
+ * Visualizer for generating an SVG-Element containing a cube as marker
+ * representing the selected range for each dimension
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.has SelectionResult oneway - - visualizes
+ * @apiviz.has RangeSelection oneway - - visualizes
+ * @apiviz.uses SVGHyperCube
+ */
+public class SelectionCubeVisualization extends AbstractScatterplotVisualization {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Selection Range";
+
+ /**
+ * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc.
+ */
+ public static final String MARKER = "selectionCubeMarker";
+
+ /**
+ * CSS class for the filled cube
+ */
+ public static final String CSS_CUBE = "selectionCube";
+
+ /**
+ * CSS class for the cube frame
+ */
+ public static final String CSS_CUBEFRAME = "selectionCubeFrame";
+
+ /**
+ * Fill parameter.
+ */
+ protected boolean nofill = false;
+
+ public SelectionCubeVisualization(VisualizationTask task, boolean nofill) {
+ super(task);
+ this.nofill = nofill;
+ addCSSClasses(svgp);
+ context.addResultListener(this);
+ incrementalRedraw();
+ }
+
+ @Override
+ public void destroy() {
+ context.removeResultListener(this);
+ super.destroy();
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ private void addCSSClasses(SVGPlot svgp) {
+ final StyleLibrary style = context.getStyleLibrary();
+ // Class for the cube
+ if(!svgp.getCSSClassManager().contains(CSS_CUBE)) {
+ CSSClass cls = new CSSClass(this, CSS_CUBE);
+ cls.setStatement(SVGConstants.CSS_STROKE_VALUE, style.getColor(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_STROKE_OPACITY_PROPERTY, style.getOpacity(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, style.getLineWidth(StyleLibrary.PLOT));
+ cls.setStatement(SVGConstants.CSS_STROKE_LINECAP_PROPERTY, SVGConstants.CSS_ROUND_VALUE);
+ cls.setStatement(SVGConstants.CSS_STROKE_LINEJOIN_PROPERTY, SVGConstants.CSS_ROUND_VALUE);
+ if(nofill) {
+ cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, SVGConstants.CSS_NONE_VALUE);
+ }
+ else {
+ cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, style.getColor(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_FILL_OPACITY_PROPERTY, style.getOpacity(StyleLibrary.SELECTION));
+ }
+ svgp.addCSSClassOrLogError(cls);
+ }
+ // Class for the cube frame
+ if(!svgp.getCSSClassManager().contains(CSS_CUBEFRAME)) {
+ CSSClass cls = new CSSClass(this, CSS_CUBEFRAME);
+ cls.setStatement(SVGConstants.CSS_STROKE_VALUE, style.getColor(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_STROKE_OPACITY_PROPERTY, style.getOpacity(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_STROKE_WIDTH_PROPERTY, style.getLineWidth(StyleLibrary.SELECTION));
+
+ svgp.addCSSClassOrLogError(cls);
+ }
+ }
+
+ /**
+ * Generates a cube and a frame depending on the selection stored in the
+ * context
+ *
+ * @param svgp The plot
+ * @param proj The projection
+ */
+ private void setSVGRect(SVGPlot svgp, Projection2D proj) {
+ DBIDSelection selContext = context.getSelection();
+ if(selContext instanceof RangeSelection) {
+ DoubleDoublePair[] ranges = ((RangeSelection) selContext).getRanges();
+ int dim = DatabaseUtil.dimensionality(rel);
+
+ double[] min = new double[dim];
+ double[] max = new double[dim];
+ for(int d = 0; d < dim; d++) {
+ if(ranges != null && ranges[d] != null) {
+ min[d] = ranges[d].first;
+ max[d] = ranges[d].second;
+ }
+ else {
+ min[d] = proj.getScale(d).getMin();
+ max[d] = proj.getScale(d).getMax();
+ }
+ }
+ if(nofill) {
+ Element r = SVGHyperCube.drawFrame(svgp, proj, min, max);
+ SVGUtil.setCSSClass(r, CSS_CUBEFRAME);
+ layer.appendChild(r);
+ }
+ else {
+ Element r = SVGHyperCube.drawFilled(svgp, CSS_CUBE, proj, min, max);
+ layer.appendChild(r);
+ }
+
+ }
+ }
+
+ @Override
+ protected void redraw() {
+ DBIDSelection selContext = context.getSelection();
+ if(selContext != null && selContext instanceof RangeSelection) {
+ setSVGRect(svgp, proj);
+ }
+ }
+
+ /**
+ * Factory for visualizers to generate an SVG-Element containing a cube as
+ * marker representing the selected range for each dimension
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses SelectionCubeVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Flag for half-transparent filling of selection cubes.
+ *
+ * <p>
+ * Key: {@code -selectionrange.nofill}
+ * </p>
+ */
+ public static final OptionID NOFILL_ID = OptionID.getOrCreateOptionID("selectionrange.nofill", "Use wireframe style for selection ranges.");
+
+ /**
+ * Fill parameter.
+ */
+ protected boolean nofill = false;
+
+ /**
+ * Constructor.
+ *
+ * @param nofill
+ */
+ public Factory(boolean nofill) {
+ super();
+ this.nofill = nofill;
+ thumbmask |= ThumbnailVisualization.ON_DATA | ThumbnailVisualization.ON_SELECTION;
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new SelectionCubeVisualization(task, nofill);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ final ArrayList<SelectionResult> selectionResults = ResultUtil.filterResults(result, SelectionResult.class);
+ for(SelectionResult selres : selectionResults) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, selres, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA - 2);
+ baseResult.getHierarchy().add(selres, task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+
+ /**
+ * Parameterization class.
+ *
+ * @author Erich Schubert
+ *
+ * @apiviz.exclude
+ */
+ public static class Parameterizer extends AbstractParameterizer {
+ protected boolean nofill;
+
+ @Override
+ protected void makeOptions(Parameterization config) {
+ super.makeOptions(config);
+ Flag nofillF = new Flag(NOFILL_ID);
+ if(config.grab(nofillF)) {
+ nofill = nofillF.getValue();
+ }
+ }
+
+ @Override
+ protected Factory makeInstance() {
+ return new Factory(nofill);
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionDotVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionDotVisualization.java new file mode 100644 index 00000000..79d1afe5 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionDotVisualization.java @@ -0,0 +1,164 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2012
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.ArrayList;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+
+import de.lmu.ifi.dbs.elki.database.datastore.DataStoreListener;
+import de.lmu.ifi.dbs.elki.database.ids.DBID;
+import de.lmu.ifi.dbs.elki.database.ids.DBIDs;
+import de.lmu.ifi.dbs.elki.result.DBIDSelection;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.result.SelectionResult;
+import de.lmu.ifi.dbs.elki.utilities.exceptions.ObjectNotFoundException;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.thumbs.ThumbnailVisualization;
+
+/**
+ * Visualizer for generating an SVG-Element containing dots as markers
+ * representing the selected Database's objects.
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.has SelectionResult oneway - - visualizes
+ * @apiviz.has DBIDSelection oneway - - visualizes
+ */
+public class SelectionDotVisualization extends AbstractScatterplotVisualization implements DataStoreListener {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Selection";
+
+ /**
+ * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc.
+ */
+ public static final String MARKER = "selectionDotMarker";
+
+ /**
+ * Constructor.
+ *
+ * @param task Task
+ */
+ public SelectionDotVisualization(VisualizationTask task) {
+ super(task);
+ context.addResultListener(this);
+ context.addDataStoreListener(this);
+ incrementalRedraw();
+ }
+
+ @Override
+ public void destroy() {
+ context.removeResultListener(this);
+ super.destroy();
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+ final double size = context.getStyleLibrary().getSize(StyleLibrary.SELECTION);
+ DBIDSelection selContext = context.getSelection();
+ if(selContext != null) {
+ DBIDs selection = selContext.getSelectedIds();
+ for(DBID i : selection) {
+ try {
+ double[] v = proj.fastProjectDataToRenderSpace(rel.get(i));
+ Element dot = svgp.svgCircle(v[0], v[1], size);
+ SVGUtil.addCSSClass(dot, MARKER);
+ layer.appendChild(dot);
+ }
+ catch(ObjectNotFoundException e) {
+ // ignore
+ }
+ }
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ private void addCSSClasses(SVGPlot svgp) {
+ // Class for the dot markers
+ if(!svgp.getCSSClassManager().contains(MARKER)) {
+ CSSClass cls = new CSSClass(this, MARKER);
+ final StyleLibrary style = context.getStyleLibrary();
+ cls.setStatement(SVGConstants.CSS_FILL_PROPERTY, style.getColor(StyleLibrary.SELECTION));
+ cls.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, style.getOpacity(StyleLibrary.SELECTION));
+ svgp.addCSSClassOrLogError(cls);
+ }
+ }
+
+ /**
+ * Factory for visualizers to generate an SVG-Element containing dots as
+ * markers representing the selected Database's objects.
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses SelectionDotVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Constructor
+ */
+ public Factory() {
+ super();
+ thumbmask |= ThumbnailVisualization.ON_DATA | ThumbnailVisualization.ON_SELECTION;
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new SelectionDotVisualization(task);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ final ArrayList<SelectionResult> selectionResults = ResultUtil.filterResults(result, SelectionResult.class);
+ for(SelectionResult selres : selectionResults) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, selres, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_DATA - 1);
+ baseResult.getHierarchy().add(selres, task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionToolCubeVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionToolCubeVisualization.java new file mode 100644 index 00000000..8e86f920 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionToolCubeVisualization.java @@ -0,0 +1,300 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2011
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.ArrayList;
+import java.util.BitSet;
+
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+import org.w3c.dom.events.Event;
+import org.w3c.dom.svg.SVGPoint;
+
+import de.lmu.ifi.dbs.elki.data.NumberVector;
+import de.lmu.ifi.dbs.elki.database.ids.DBID;
+import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil;
+import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs;
+import de.lmu.ifi.dbs.elki.logging.Logging;
+import de.lmu.ifi.dbs.elki.result.DBIDSelection;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.RangeSelection;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.result.SelectionResult;
+import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleDoublePair;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.batikutil.DragableArea;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projections.Projection;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+
+/**
+ * Tool-Visualization for the tool to select ranges
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.has SelectionResult oneway - - updates
+ * @apiviz.has RangeSelection oneway - - updates
+ */
+public class SelectionToolCubeVisualization extends AbstractScatterplotVisualization implements DragableArea.DragListener {
+ /**
+ * The logger for this class.
+ */
+ protected static final Logging logger = Logging.getLogger(SelectionToolCubeVisualization.class);
+
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Range Selection";
+
+ /**
+ * Generic tag to indicate the type of element. Used in IDs, CSS-Classes etc.
+ */
+ private static final String CSS_RANGEMARKER = "selectionRangeMarker";
+
+ /**
+ * Dimension
+ */
+ private int dim;
+
+ /**
+ * Element for selection rectangle
+ */
+ private Element rtag;
+
+ /**
+ * Element for the rectangle to add listeners
+ */
+ private Element etag;
+
+ /**
+ * Constructor.
+ *
+ * @param task Task
+ */
+ public SelectionToolCubeVisualization(VisualizationTask task) {
+ super(task);
+ this.dim = DatabaseUtil.dimensionality(rel);
+ incrementalRedraw();
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+
+ // rtag: tag for the selected rect
+ rtag = svgp.svgElement(SVGConstants.SVG_G_TAG);
+ SVGUtil.addCSSClass(rtag, CSS_RANGEMARKER);
+ layer.appendChild(rtag);
+
+ // etag: sensitive area
+ DragableArea drag = new DragableArea(svgp, -0.6 * StyleLibrary.SCALE, -0.7 * StyleLibrary.SCALE, 1.3 * StyleLibrary.SCALE, 1.4 * StyleLibrary.SCALE, this);
+ etag = drag.getElement();
+ layer.appendChild(etag);
+ }
+
+ /**
+ * Delete the children of the element
+ *
+ * @param container SVG-Element
+ */
+ private void deleteChildren(Element container) {
+ while(container.hasChildNodes()) {
+ container.removeChild(container.getLastChild());
+ }
+ }
+
+ /**
+ * Set the selected ranges and the mask for the actual dimensions in the
+ * context
+ *
+ * @param x1 x-value of the first dimension
+ * @param x2 x-value of the second dimension
+ * @param y1 y-value of the first dimension
+ * @param y2 y-value of the second dimension
+ */
+ private void updateSelectionRectKoordinates(double x1, double x2, double y1, double y2, DoubleDoublePair[] ranges) {
+ BitSet actDim = proj.getVisibleDimensions2D();
+ double[] v1 = new double[dim];
+ double[] v2 = new double[dim];
+ v1[0] = x1;
+ v1[1] = y1;
+ v2[0] = x2;
+ v2[1] = y2;
+
+ double[] nv1 = proj.fastProjectRenderToDataSpace(v1);
+ double[] nv2 = proj.fastProjectRenderToDataSpace(v2);
+
+ for(int d = actDim.nextSetBit(0); d >= 0; d = actDim.nextSetBit(d + 1)) {
+ ranges[d] = new DoubleDoublePair(Math.min(nv1[d], nv2[d]), Math.max(nv1[d], nv2[d]));
+ }
+ }
+
+ @Override
+ public boolean startDrag(SVGPoint startPoint, Event evt) {
+ return true;
+ }
+
+ @Override
+ public boolean duringDrag(SVGPoint startPoint, SVGPoint dragPoint, Event evt, boolean inside) {
+ deleteChildren(rtag);
+ double x = Math.min(startPoint.getX(), dragPoint.getX());
+ double y = Math.min(startPoint.getY(), dragPoint.getY());
+ double width = Math.abs(startPoint.getX() - dragPoint.getX());
+ double height = Math.abs(startPoint.getY() - dragPoint.getY());
+ rtag.appendChild(svgp.svgRect(x, y, width, height));
+ return true;
+ }
+
+ @Override
+ public boolean endDrag(SVGPoint startPoint, SVGPoint dragPoint, Event evt, boolean inside) {
+ deleteChildren(rtag);
+ if(startPoint.getX() != dragPoint.getX() || startPoint.getY() != dragPoint.getY()) {
+ updateSelection(proj, startPoint, dragPoint);
+ }
+ return true;
+ }
+
+ /**
+ * Update the selection in the context.
+ *
+ * @param proj The projection
+ * @param p1 First Point of the selected rectangle
+ * @param p2 Second Point of the selected rectangle
+ */
+ private void updateSelection(Projection proj, SVGPoint p1, SVGPoint p2) {
+ DBIDSelection selContext = context.getSelection();
+ ModifiableDBIDs selection;
+ if(selContext != null) {
+ selection = DBIDUtil.newHashSet(selContext.getSelectedIds());
+ }
+ else {
+ selection = DBIDUtil.newHashSet();
+ }
+ DoubleDoublePair[] ranges;
+
+ if(p1 == null || p2 == null) {
+ logger.warning("no rect selected: p1: " + p1 + " p2: " + p2);
+ }
+ else {
+ double x1 = Math.min(p1.getX(), p2.getX());
+ double x2 = Math.max(p1.getX(), p2.getX());
+ double y1 = Math.max(p1.getY(), p2.getY());
+ double y2 = Math.min(p1.getY(), p2.getY());
+
+ if(selContext instanceof RangeSelection) {
+ ranges = ((RangeSelection) selContext).getRanges();
+ }
+ else {
+ ranges = new DoubleDoublePair[dim];
+ }
+ updateSelectionRectKoordinates(x1, x2, y1, y2, ranges);
+
+ selection.clear();
+ boolean idIn = true;
+ for(DBID id : rel.iterDBIDs()) {
+ NumberVector<?, ?> dbTupel = rel.get(id);
+ idIn = true;
+ for(int i = 0; i < dim; i++) {
+ if(ranges != null && ranges[i] != null) {
+ if(dbTupel.doubleValue(i + 1) < ranges[i].first || dbTupel.doubleValue(i + 1) > ranges[i].second) {
+ idIn = false;
+ break;
+ }
+ }
+ }
+ if(idIn == true) {
+ selection.add(id);
+ }
+ }
+ context.setSelection(new RangeSelection(selection, ranges));
+ }
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ protected void addCSSClasses(SVGPlot svgp) {
+ // Class for the range marking
+ if(!svgp.getCSSClassManager().contains(CSS_RANGEMARKER)) {
+ final CSSClass rcls = new CSSClass(this, CSS_RANGEMARKER);
+ final StyleLibrary style = context.getStyleLibrary();
+ rcls.setStatement(SVGConstants.CSS_FILL_PROPERTY, style.getColor(StyleLibrary.SELECTION_ACTIVE));
+ rcls.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, style.getOpacity(StyleLibrary.SELECTION_ACTIVE));
+ svgp.addCSSClassOrLogError(rcls);
+ }
+ }
+
+ /**
+ * Factory for tool visualizations for selecting ranges and the inclosed
+ * objects
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses SelectionToolCubeVisualization oneway - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Constructor, adhering to
+ * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable}
+ */
+ public Factory() {
+ super();
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new SelectionToolCubeVisualization(task);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ final ArrayList<SelectionResult> selectionResults = ResultUtil.filterResults(result, SelectionResult.class);
+ for(SelectionResult selres : selectionResults) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, selres, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_INTERACTIVE);
+ task.put(VisualizationTask.META_TOOL, true);
+ task.put(VisualizationTask.META_NOTHUMB, true);
+ task.put(VisualizationTask.META_NOEXPORT, true);
+ task.put(VisualizationTask.META_VISIBLE_DEFAULT, false);
+ baseResult.getHierarchy().add(selres, task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionToolDotVisualization.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionToolDotVisualization.java new file mode 100644 index 00000000..877833f7 --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/SelectionToolDotVisualization.java @@ -0,0 +1,275 @@ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection;
+
+/*
+ This file is part of ELKI:
+ Environment for Developing KDD-Applications Supported by Index-Structures +
+ Copyright (C) 2011
+ Ludwig-Maximilians-Universität München
+ Lehr- und Forschungseinheit für Datenbanksysteme
+ ELKI Development Team +
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 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 Affero General Public License for more details. +
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.util.ArrayList;
+
+import org.apache.batik.dom.events.DOMMouseEvent;
+import org.apache.batik.util.SVGConstants;
+import org.w3c.dom.Element;
+import org.w3c.dom.events.Event;
+import org.w3c.dom.svg.SVGPoint;
+
+import de.lmu.ifi.dbs.elki.database.ids.DBID;
+import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil;
+import de.lmu.ifi.dbs.elki.database.ids.HashSetModifiableDBIDs;
+import de.lmu.ifi.dbs.elki.result.DBIDSelection;
+import de.lmu.ifi.dbs.elki.result.HierarchicalResult;
+import de.lmu.ifi.dbs.elki.result.Result;
+import de.lmu.ifi.dbs.elki.result.ResultUtil;
+import de.lmu.ifi.dbs.elki.result.SelectionResult;
+import de.lmu.ifi.dbs.elki.utilities.iterator.IterableIterator;
+import de.lmu.ifi.dbs.elki.visualization.VisualizationTask;
+import de.lmu.ifi.dbs.elki.visualization.batikutil.DragableArea;
+import de.lmu.ifi.dbs.elki.visualization.css.CSSClass;
+import de.lmu.ifi.dbs.elki.visualization.projections.Projection2D;
+import de.lmu.ifi.dbs.elki.visualization.projector.ScatterPlotProjector;
+import de.lmu.ifi.dbs.elki.visualization.style.StyleLibrary;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGPlot;
+import de.lmu.ifi.dbs.elki.visualization.svg.SVGUtil;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.AbstractVisFactory;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.Visualization;
+import de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.AbstractScatterplotVisualization;
+
+/**
+ * Tool-Visualization for the tool to select objects
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.has SelectionResult oneway - - updates
+ * @apiviz.has DBIDSelection oneway - - updates
+ */
+public class SelectionToolDotVisualization extends AbstractScatterplotVisualization implements DragableArea.DragListener {
+ /**
+ * A short name characterizing this Visualizer.
+ */
+ private static final String NAME = "Object Selection";
+
+ /**
+ * CSS class of the selection rectangle while selecting.
+ */
+ private static final String CSS_RANGEMARKER = "selectionRangeMarker";
+
+ /**
+ * Input modes
+ *
+ * @apiviz.exclude
+ */
+ private enum Mode {
+ REPLACE, ADD, INVERT
+ }
+
+ /**
+ * Element for selection rectangle
+ */
+ Element rtag;
+
+ /**
+ * Element for the rectangle to add listeners
+ */
+ Element etag;
+
+ /**
+ * Constructor.
+ *
+ * @param task Task
+ */
+ public SelectionToolDotVisualization(VisualizationTask task) {
+ super(task);
+ incrementalRedraw();
+ }
+
+ @Override
+ protected void redraw() {
+ addCSSClasses(svgp);
+
+ //
+ rtag = svgp.svgElement(SVGConstants.SVG_G_TAG);
+ SVGUtil.addCSSClass(rtag, CSS_RANGEMARKER);
+ layer.appendChild(rtag);
+
+ // etag: sensitive area
+ DragableArea drag = new DragableArea(svgp, -0.6 * StyleLibrary.SCALE, -0.7 * StyleLibrary.SCALE, 1.3 * StyleLibrary.SCALE, 1.4 * StyleLibrary.SCALE, this);
+ etag = drag.getElement();
+ layer.appendChild(etag);
+ }
+
+ /**
+ * Delete the children of the element
+ *
+ * @param container SVG-Element
+ */
+ private void deleteChildren(Element container) {
+ while(container.hasChildNodes()) {
+ container.removeChild(container.getLastChild());
+ }
+ }
+
+ @Override
+ public boolean startDrag(SVGPoint startPoint, Event evt) {
+ return true;
+ }
+
+ @Override
+ public boolean duringDrag(SVGPoint startPoint, SVGPoint dragPoint, Event evt, boolean inside) {
+ deleteChildren(rtag);
+ double x = Math.min(startPoint.getX(), dragPoint.getX());
+ double y = Math.min(startPoint.getY(), dragPoint.getY());
+ double width = Math.abs(startPoint.getX() - dragPoint.getX());
+ double height = Math.abs(startPoint.getY() - dragPoint.getY());
+ rtag.appendChild(svgp.svgRect(x, y, width, height));
+ return true;
+ }
+
+ @Override
+ public boolean endDrag(SVGPoint startPoint, SVGPoint dragPoint, Event evt, boolean inside) {
+ Mode mode = getInputMode(evt);
+ deleteChildren(rtag);
+ if(startPoint.getX() != dragPoint.getX() || startPoint.getY() != dragPoint.getY()) {
+ updateSelection(mode, proj, startPoint, dragPoint);
+ }
+ return true;
+ }
+
+ /**
+ * Get the current input mode, on each mouse event.
+ *
+ * @param evt Mouse event.
+ * @return current input mode
+ */
+ private Mode getInputMode(Event evt) {
+ if(evt instanceof DOMMouseEvent) {
+ DOMMouseEvent domme = (DOMMouseEvent) evt;
+ // TODO: visual indication of mode possible?
+ if(domme.getShiftKey()) {
+ return Mode.ADD;
+ }
+ else if(domme.getCtrlKey()) {
+ return Mode.INVERT;
+ }
+ else {
+ return Mode.REPLACE;
+ }
+ }
+ // Default mode is replace.
+ return Mode.REPLACE;
+ }
+
+ /**
+ * Updates the selection in the context.<br>
+ *
+ * @param mode Input mode
+ * @param proj
+ * @param p1 first point of the selected rectangle
+ * @param p2 second point of the selected rectangle
+ */
+ private void updateSelection(Mode mode, Projection2D proj, SVGPoint p1, SVGPoint p2) {
+ DBIDSelection selContext = context.getSelection();
+ // Note: we rely on SET semantics below!
+ HashSetModifiableDBIDs selection;
+ if(selContext == null || mode == Mode.REPLACE) {
+ selection = DBIDUtil.newHashSet();
+ }
+ else {
+ selection = DBIDUtil.newHashSet(selContext.getSelectedIds());
+ }
+ for(DBID id : rel.iterDBIDs()) {
+ double[] vec = proj.fastProjectDataToRenderSpace(rel.get(id));
+ if(vec[0] >= Math.min(p1.getX(), p2.getX()) && vec[0] <= Math.max(p1.getX(), p2.getX()) && vec[1] >= Math.min(p1.getY(), p2.getY()) && vec[1] <= Math.max(p1.getY(), p2.getY())) {
+ if(mode == Mode.INVERT) {
+ if(!selection.contains(id)) {
+ selection.add(id);
+ }
+ else {
+ selection.remove(id);
+ }
+ }
+ else {
+ // In REPLACE and ADD, add objects.
+ // The difference was done before by not re-using the selection.
+ // Since we are using a set, we can just add in any case.
+ selection.add(id);
+ }
+ }
+ }
+ context.setSelection(new DBIDSelection(selection));
+ }
+
+ /**
+ * Adds the required CSS-Classes
+ *
+ * @param svgp SVG-Plot
+ */
+ protected void addCSSClasses(SVGPlot svgp) {
+ // Class for the range marking
+ if(!svgp.getCSSClassManager().contains(CSS_RANGEMARKER)) {
+ final CSSClass rcls = new CSSClass(this, CSS_RANGEMARKER);
+ final StyleLibrary style = context.getStyleLibrary();
+ rcls.setStatement(SVGConstants.CSS_FILL_PROPERTY, style.getColor(StyleLibrary.SELECTION_ACTIVE));
+ rcls.setStatement(SVGConstants.CSS_OPACITY_PROPERTY, style.getOpacity(StyleLibrary.SELECTION_ACTIVE));
+ svgp.addCSSClassOrLogError(rcls);
+ }
+ }
+
+ /**
+ * Factory for tool visualizations for selecting objects
+ *
+ * @author Heidi Kolb
+ *
+ * @apiviz.stereotype factory
+ * @apiviz.uses SelectionToolDotVisualization - - «create»
+ */
+ public static class Factory extends AbstractVisFactory {
+ /**
+ * Constructor, adhering to
+ * {@link de.lmu.ifi.dbs.elki.utilities.optionhandling.Parameterizable}
+ */
+ public Factory() {
+ super();
+ }
+
+ @Override
+ public Visualization makeVisualization(VisualizationTask task) {
+ return new SelectionToolDotVisualization(task);
+ }
+
+ @Override
+ public void processNewResult(HierarchicalResult baseResult, Result result) {
+ final ArrayList<SelectionResult> selectionResults = ResultUtil.filterResults(result, SelectionResult.class);
+ for(SelectionResult selres : selectionResults) {
+ IterableIterator<ScatterPlotProjector<?>> ps = ResultUtil.filteredResults(baseResult, ScatterPlotProjector.class);
+ for(ScatterPlotProjector<?> p : ps) {
+ final VisualizationTask task = new VisualizationTask(NAME, selres, p.getRelation(), this);
+ task.put(VisualizationTask.META_LEVEL, VisualizationTask.LEVEL_INTERACTIVE);
+ task.put(VisualizationTask.META_TOOL, true);
+ task.put(VisualizationTask.META_NOTHUMB, true);
+ task.put(VisualizationTask.META_NOEXPORT, true);
+ task.put(VisualizationTask.META_VISIBLE_DEFAULT, false);
+ baseResult.getHierarchy().add(selres, task);
+ baseResult.getHierarchy().add(p, task);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/package-info.java b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/package-info.java new file mode 100644 index 00000000..3710de5c --- /dev/null +++ b/src/de/lmu/ifi/dbs/elki/visualization/visualizers/scatterplot/selection/package-info.java @@ -0,0 +1,26 @@ +/** + * <p>Visualizers for object selection based on 2D projections.</p> + */ +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2012 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +package de.lmu.ifi.dbs.elki.visualization.visualizers.scatterplot.selection;
\ No newline at end of file |