/** * Converts argument to DoubleCell if it does not fully support the DataValue interfaces supported * by DoubleCell.TYPE . * * @param cell Cell to convert (or not) * @return The argument or a new DoubleCell. */ private DataCell convertToDoubleCellIfNecessary(final DataCell cell) { if (cell.isMissing()) { return DataType.getMissingCell(); } if (TYPE.isASuperTypeOf(cell.getType())) { return cell; } return new DoubleCell(((DoubleValue) cell).getDoubleValue()); }
@Override protected DataTableSpec[] configure(DataTableSpec[] inSpecs) throws InvalidSettingsException { DataType type = inSpecs[0].iterator().next().getType(); if (type.isCollectionType()) { throw new InvalidSettingsException("collection type at port 0 detected"); } outspec = getOutSpec(type); return outspec; }
/** {@inheritDoc} */ @Override protected DataCell getResultInternal() { if (m_cells.size() == 0) { return DataType.getMissingCell(); } if (m_cells.size() == 1) { return convertToDoubleCellIfNecessary(m_cells.get(0)); } Collections.sort(m_cells, m_comparator); final double middle = m_cells.size() / 2.0; if (middle > (int) middle) { return convertToDoubleCellIfNecessary(m_cells.get((int) middle)); } // the list is even return the middle two final double val1 = ((DoubleValue) m_cells.get((int) middle - 1)).getDoubleValue(); final double val2 = ((DoubleValue) m_cells.get((int) middle)).getDoubleValue(); return new DoubleCell((val1 + val2) / 2); }
@Override protected void updateComponent() { if (beforeLoad) { // This is immediately *after* load! newColumns.clear(); newColumns.addAll( Arrays.asList(((SettingsModelStringArray) getModel()).getStringArrayValue())); beforeLoad = false; // Never again } final PortObjectSpec lastTableSpec = getLastTableSpec(portIndex); final List<DataRow> dataRows = new ArrayList<DataRow>(); final List<DataColumnSpec> colSpecs = new ArrayList<DataColumnSpec>(); if (lastTableSpec instanceof DataTableSpec) { final DataTableSpec spec = (DataTableSpec) lastTableSpec; try { final Map<List<String>, Map<String, Integer>> parts = UnpivotNodeModel.createParts(pattern.getStringValue(), spec); final Set<Integer> participating = new HashSet<Integer>(); for (final Map<String, Integer> map : parts.values()) { for (final Integer i : map.values()) { participating.add(i); } } for (int i = 0; i < spec.getNumColumns(); ++i) { if (!participating.contains(Integer.valueOf(i))) { colSpecs.add(spec.getColumnSpec(i)); } } singleCount = colSpecs.size(); int rowCount = 0; if (parts.isEmpty() || newColumns.size() != parts.keySet().iterator().next().size()) { newColumns.clear(); if (!parts.isEmpty()) { // Fill with defaults for (int i = parts.keySet().iterator().next().size(); i-- > 0; ) { final String colName = "Col_" + i; newColumns.add(colName); colSpecs.add(new DataColumnSpecCreator(colName, StringCell.TYPE).createSpec()); } } } else { for (final String colName : newColumns) { colSpecs.add(new DataColumnSpecCreator(colName, StringCell.TYPE).createSpec()); } } final Map<String, DataType> types = new LinkedHashMap<String, DataType>(); for (final Entry<List<String>, Map<String, Integer>> outer : parts.entrySet()) { final Map<String, Integer> map = outer.getValue(); for (final Entry<String, Integer> entry : map.entrySet()) { final String colName = entry.getKey(); final DataType origType = types.get(colName); if (origType == null) { types.put(colName, spec.getColumnSpec(entry.getValue().intValue()).getType()); } else { types.put( colName, DataType.getCommonSuperType( origType, spec.getColumnSpec(entry.getValue().intValue()).getType())); } } } for (final Entry<String, DataType> entry : types.entrySet()) { colSpecs.add(new DataColumnSpecCreator(entry.getKey(), entry.getValue()).createSpec()); } for (final Entry<List<String>, Map<String, Integer>> entry : parts.entrySet()) { final List<DataCell> cells = new ArrayList<DataCell>(colSpecs.size()); for (int i = singleCount; i-- > 0; ) { cells.add(DataType.getMissingCell()); } for (final String val : entry.getKey()) { cells.add(new StringCell(val)); } for (final Entry<String, Integer> inner : entry.getValue().entrySet()) { final DataColumnDomain domain = spec.getColumnSpec(inner.getValue().intValue()).getDomain(); cells.add( domain.getLowerBound() == null ? domain.getValues() == null || domain.getValues().isEmpty() ? DataType.getMissingCell() : domain.getValues().iterator().next() : domain.getLowerBound()); } dataRows.add(new DefaultRow("Row" + rowCount, cells)); ++rowCount; } } catch (final PatternSyntaxException e) { for (final DataColumnSpec dataColumnSpec : spec) { colSpecs.add(dataColumnSpec); } } } @SuppressWarnings("deprecation") final DataTable data = new org.knime.core.data.def.DefaultTable( dataRows.toArray(new DataRow[dataRows.size()]), new DataTableSpec(colSpecs.toArray(new DataColumnSpec[colSpecs.size()]))); table.setDataTable(data); table.repaint(); }
public class MADOperator extends AggregationOperator { private static final DataType TYPE = DoubleCell.TYPE; private final List<DataCell> m_cells; private final Comparator<DataCell> m_comparator = TYPE.getComparator(); public MADOperator( OperatorData operatorData, GlobalSettings globalSettings, OperatorColumnSettings opColSettings) { super(operatorData, globalSettings, opColSettings); // TODO Auto-generated constructor stub try { m_cells = new ArrayList<DataCell>(getMaxUniqueValues()); } catch (final OutOfMemoryError e) { throw new IllegalArgumentException("Maximum unique values number too big"); } } /** * Constructor for class MedianOperator. * * @param globalSettings the global settings * @param opColSettings the operator column specific settings */ public MADOperator( final GlobalSettings globalSettings, final OperatorColumnSettings opColSettings) { this( new OperatorData("MAD", true, false, DoubleValue.class, false), globalSettings, setInclMissingFlag(opColSettings)); } public MADOperator() { this( new OperatorData("MAD", false, false, DoubleValue.class, false), new GlobalSettings(0), new OperatorColumnSettings(false, null)); } /** * Ensure that the flag is set correctly since this method does not support changing of the * missing cell handling option. * * @param opColSettings the {@link OperatorColumnSettings} to set * @return the correct {@link OperatorColumnSettings} */ private static OperatorColumnSettings setInclMissingFlag( final OperatorColumnSettings opColSettings) { opColSettings.setInclMissing(false); return opColSettings; } /** {@inheritDoc} */ @Override protected DataType getDataType(final DataType origType) { return TYPE; } /** {@inheritDoc} */ @Override protected boolean computeInternal(final DataCell cell) { if (cell.isMissing()) { return false; } if (m_cells.size() >= getMaxUniqueValues()) { return true; } m_cells.add(cell); return false; } /** {@inheritDoc} */ @Override public AggregationOperator createInstance( final GlobalSettings globalSettings, final OperatorColumnSettings opColSettings) { return new MedianOperator(globalSettings, opColSettings); } /** {@inheritDoc} */ @Override protected DataCell getResultInternal() { if (m_cells.size() == 0) { return DataType.getMissingCell(); } if (m_cells.size() == 1) { return convertToDoubleCellIfNecessary(m_cells.get(0)); } Collections.sort(m_cells, m_comparator); final double middle = m_cells.size() / 2.0; if (middle > (int) middle) { return convertToDoubleCellIfNecessary(m_cells.get((int) middle)); } // the list is even return the middle two final double val1 = ((DoubleValue) m_cells.get((int) middle - 1)).getDoubleValue(); final double val2 = ((DoubleValue) m_cells.get((int) middle)).getDoubleValue(); return new DoubleCell((val1 + val2) / 2); } /** * Converts argument to DoubleCell if it does not fully support the DataValue interfaces supported * by DoubleCell.TYPE . * * @param cell Cell to convert (or not) * @return The argument or a new DoubleCell. */ private DataCell convertToDoubleCellIfNecessary(final DataCell cell) { if (cell.isMissing()) { return DataType.getMissingCell(); } if (TYPE.isASuperTypeOf(cell.getType())) { return cell; } return new DoubleCell(((DoubleValue) cell).getDoubleValue()); } /** {@inheritDoc} */ @Override protected void resetInternal() { m_cells.clear(); } /** {@inheritDoc} */ @Override public String getDescription() { return "Calculates the median of a list of numbers. " + "Missing cells are skipped."; } }
@Override protected BufferedDataTable[] execute(BufferedDataTable[] inData, ExecutionContext exec) throws Exception { List<File> inputFiles = FileSelectPanel.getInputFiles(propInputDir.getStringValue(), getAllowedFileExtensions()); if (inputFiles.isEmpty()) { throw new RuntimeException("No files selected"); } // first group files into plate-groups Map<String, List<File>> plateFiles = splitFilesIntoPlates(inputFiles); if (inputFiles.isEmpty()) { throw new RuntimeException("No valid envision-files in selection " + inputFiles); } // split files List<String> allAttributes = mergeAttributes(plateFiles); List<Attribute> colAttributes = compileColumnModel(allAttributes); DataTableSpec outputSpec = AttributeUtils.compileTableSpecs(colAttributes); BufferedDataContainer container = exec.createDataContainer(outputSpec); // populate the table int fileCounter = 0, rowCounter = 0; for (String barcode : plateFiles.keySet()) { logger.info("Processing plate " + barcode); Plate plate = new Plate(); // invalidate plate-dims as these become fixed in the loop plate.setNumColumns(-1); plate.setNumRows(-1); for (File file : plateFiles.get(barcode)) { String attributeName = getAttributeNameOfEnvisionFile(file); parseFile(plate, attributeName, file); BufTableUtils.updateProgress(exec, fileCounter++, inputFiles.size()); } // now create the data-rows for this table for (Well well : plate.getWells()) { if (well.getReadOutNames().isEmpty()) { continue; } DataCell[] knimeRow = new DataCell[colAttributes.size()]; // first add the barcode-column knimeRow[0] = new StringCell(barcode); knimeRow[1] = colAttributes.get(1).createCell(well.getPlateRow()); knimeRow[2] = colAttributes.get(2).createCell(well.getPlateColumn()); for (String attributeName : allAttributes) { int rowIndex = allAttributes.indexOf(attributeName); Double value = well.getReadout(attributeName); if (value != null) { knimeRow[3 + rowIndex] = new DoubleCell(value); } else { knimeRow[3 + rowIndex] = DataType.getMissingCell(); } } DataRow tableRow = new DefaultRow(new RowKey("" + rowCounter++), knimeRow); container.addRowToTable(tableRow); } } container.close(); return new BufferedDataTable[] {container.getTable()}; }