protected OperationData process(IDataset input, IMonitor monitor) throws OperationException {
double d = (2 * Math.PI) / model.getqValue();
double p = (2 * Math.PI) / (model.getqValue() + model.getqDelta());
double m = (2 * Math.PI) / (model.getqValue() - model.getqDelta());
IDiffractionMetadata dm = getFirstDiffractionMetadata(input);
if (dm == null) throw new OperationException(this, "No calibration information!");
IParametricROI[] inOut = new IParametricROI[2];
IParametricROI conic =
(IParametricROI)
DSpacing.conicFromDSpacing(
dm.getDetector2DProperties(), dm.getDiffractionCrystalEnvironment(), d);
inOut[0] =
(IParametricROI)
DSpacing.conicFromDSpacing(
dm.getDetector2DProperties(), dm.getDiffractionCrystalEnvironment(), m);
inOut[1] =
(IParametricROI)
DSpacing.conicFromDSpacing(
dm.getDetector2DProperties(), dm.getDiffractionCrystalEnvironment(), p);
PolylineROI points =
PeakFittingEllipseFinder.findPointsOnConic(
DatasetUtils.convertToDataset(input), null, conic, inOut, 256, null);
double rms = -1;
double[] semi = new double[2];
double[] point = new double[2];
double ang = 0;
if (points != null && points.getNumberOfPoints() < 3) {
EllipticalFitROI efroi = PowderRingsUtils.fitAndTrimOutliers(null, points, 2, false);
rms = efroi.getRMS();
semi = efroi.getSemiAxes();
point = efroi.getPoint();
ang = efroi.getAngleDegrees();
}
Dataset r = DatasetFactory.createFromObject(new double[] {rms});
r.setName("rms");
Dataset ax = DatasetFactory.createFromObject(semi);
ax.setName("semi-axes");
Dataset po = DatasetFactory.createFromObject(point);
po.setName("centre");
Dataset a = DatasetFactory.createFromObject(new double[] {ang});
a.setName("angle");
return new OperationData(input, new Serializable[] {r, ax, po, a});
}
@Override
protected Collection<? extends ITrace> createProfile(
final IImageTrace image,
IRegion region,
IROI rbs,
boolean tryUpdate,
boolean isDrag,
IProgressMonitor monitor) {
if (monitor.isCanceled()) return null;
if (image == null) return null;
if ((region.getRegionType() != RegionType.BOX)
&& (region.getRegionType() != RegionType.PERIMETERBOX)) return null;
Dataset slice = createZoom(image, region, rbs, tryUpdate, isDrag, monitor);
Dataset yData = slice.sum(0);
yData.setName("Intensity");
Dataset xData = slice.sum(1);
xData.setName("Intensity");
final RectangularROI bounds = (RectangularROI) (rbs == null ? region.getROI() : rbs);
final Dataset y_indices =
DatasetFactory.createRange(
bounds.getPoint()[0], bounds.getPoint()[0] + bounds.getLength(0), 1, Dataset.FLOAT);
y_indices.setName("X Location");
topSystem.updatePlot1D(y_indices, Arrays.asList(new IDataset[] {yData}), monitor);
topSystem.repaint();
final Dataset x_indices =
DatasetFactory.createRange(
bounds.getPoint()[1] + bounds.getLength(1), bounds.getPoint()[1], -1, Dataset.FLOAT);
x_indices.setName("Y Location");
final Collection<ITrace> right =
rightSystem.updatePlot1D(xData, Arrays.asList(new IDataset[] {x_indices}), monitor);
rightSystem.repaint();
Display.getDefault()
.syncExec(
new Runnable() {
@Override
public void run() {
topSystem.setTitle("");
rightSystem.setTitle("");
ILineTrace line = (ILineTrace) right.iterator().next();
line.setTraceColor(ColorConstants.red);
}
});
return profilePlottingSystem.getTraces();
}
protected Dataset createZoom(
final IImageTrace image,
IRegion region,
IROI rbs,
boolean tryUpdate,
boolean isDrag,
IProgressMonitor monitor) {
if (!(region.getROI() instanceof RectangularROI)) return null;
final RectangularROI bounds = (RectangularROI) (rbs == null ? region.getROI() : rbs);
if (bounds == null) return null;
if (!region.isVisible()) return null;
if (monitor.isCanceled()) return null;
final int yInc = bounds.getPoint()[1] < bounds.getEndPoint()[1] ? 1 : -1;
final int xInc = bounds.getPoint()[0] < bounds.getEndPoint()[0] ? 1 : -1;
Dataset im = DatasetUtils.convertToDataset(image.getData());
Dataset slice = DatasetUtils.convertToDataset(ToolUtils.getClippedSlice(im, bounds));
slice.setName(region.getName());
// Calculate axes to have real values not size
Dataset yLabels = null;
Dataset xLabels = null;
if (image.getAxes() != null && image.getAxes().size() > 0) {
Dataset xl = DatasetUtils.convertToDataset(image.getAxes().get(0));
if (xl != null) xLabels = ZoomTool.getLabelsFromLabels(xl, bounds, 0);
Dataset yl = DatasetUtils.convertToDataset(image.getAxes().get(1));
if (yl != null) yLabels = ZoomTool.getLabelsFromLabels(yl, bounds, 1);
}
if (yLabels == null)
yLabels =
DatasetFactory.createRange(
IntegerDataset.class, bounds.getPoint()[1], bounds.getEndPoint()[1], yInc);
if (xLabels == null)
xLabels =
DatasetFactory.createRange(
IntegerDataset.class, bounds.getPoint()[0], bounds.getEndPoint()[0], xInc);
final IImageTrace zoom_trace =
(IImageTrace)
profilePlottingSystem.updatePlot2D(
slice, Arrays.asList(new IDataset[] {xLabels, yLabels}), monitor);
registerTraces(region, Arrays.asList(new ITrace[] {zoom_trace}));
Display.getDefault()
.syncExec(
new Runnable() {
public void run() {
zoom_trace.setPaletteData(image.getPaletteData());
}
});
return slice;
}
@Override
protected OperationData process(IDataset input, IMonitor monitor) {
double theta = 0;
try {
theta = ScanMetadata.getTheta(input);
} catch (Exception e) {
}
NormalDistribution beamfootprint =
new NormalDistribution(
0, (1e-3 * model.getBeamHeight() / 2 * Math.sqrt(2 * Math.log(2) - 0.5)));
double areaCorrection =
2
* (beamfootprint.cumulativeProbability(
(model.getFootprint()
* Math.sin((theta + model.getAngularFudgeFactor()) * Math.PI / 180))));
Dataset output = DatasetUtils.cast(input, Dataset.FLOAT64);
output = Maths.multiply(input, areaCorrection);
Dataset outputSum =
DatasetFactory.createFromObject((DatasetUtils.cast(output, Dataset.FLOAT64)).sum());
return new OperationData(output, outputSum);
}
@Override
protected OperationData process(IDataset input, IMonitor monitor) {
RectangularROI box = model.getBox();
Dataset in1 =
BoxSlicerRodScanUtils.rOIBox(input, monitor, box.getIntLengths(), box.getIntPoint());
if (g2 == null) g2 = new Polynomial2D(model.getFitPower());
if ((int) Math.pow(model.getFitPower() + 1, 2) != g2.getNoOfParameters())
g2 = new Polynomial2D(model.getFitPower());
Dataset[] fittingBackground =
BoxSlicerRodScanUtils.LeftRightTopBottomBoxes(
input, monitor, box.getIntLengths(), box.getIntPoint(), model.getBoundaryBox());
Dataset offset = DatasetFactory.ones(fittingBackground[2].getShape(), Dataset.FLOAT64);
Dataset intermediateFitTest = Maths.add(offset, fittingBackground[2]);
Dataset matrix =
LinearLeastSquaresServicesForSXRD.polynomial2DLinearLeastSquaresMatrixGenerator(
model.getFitPower(), fittingBackground[0], fittingBackground[1]);
DoubleDataset test = (DoubleDataset) LinearAlgebra.solveSVD(matrix, intermediateFitTest);
double[] params = test.getData();
DoubleDataset in1Background =
g2.getOutputValues0(
params, box.getIntLengths(), model.getBoundaryBox(), model.getFitPower());
IndexIterator it = in1Background.getIterator();
while (it.hasNext()) {
double v = in1Background.getElementDoubleAbs(it.index);
if (v < 0) in1Background.setObjectAbs(it.index, 0);
}
Dataset pBackgroundSubtracted = Maths.subtract(in1, in1Background, null);
pBackgroundSubtracted.setName("pBackgroundSubtracted");
IndexIterator it1 = pBackgroundSubtracted.getIterator();
while (it1.hasNext()) {
double q = pBackgroundSubtracted.getElementDoubleAbs(it1.index);
if (q < 0) pBackgroundSubtracted.setObjectAbs(it1.index, 0);
}
Dataset output = DatasetUtils.cast(pBackgroundSubtracted, Dataset.FLOAT64);
output.setName("Region of Interest, polynomial background removed");
return new OperationData(output);
}
private void populateDataBasedFunctions(
final Map<String, Serializable> data, IFunction function) {
if (function instanceof CompositeFunction) {
CompositeFunction compositeFunction = (CompositeFunction) function;
for (IFunction func : compositeFunction.getFunctions()) {
populateDataBasedFunctions(data, func);
}
}
if (function instanceof IDataBasedFunction) {
IDataBasedFunction dbFunction = (IDataBasedFunction) function;
String sdName = seedDataName.getExpression();
String sdAxis = seedAxisName.getExpression();
Dataset seedDataset = DatasetFactory.createFromObject(data.get(sdName)).clone();
Dataset seedAxisDataset = DatasetFactory.createFromObject(data.get(sdAxis)).clone();
dbFunction.setData(seedAxisDataset, seedDataset);
}
}
@SuppressWarnings("unchecked")
public static String getTitle(
final IDataset xIn,
final List<? extends IDataset> ysIn,
final boolean isFileName,
final String rootName) {
final IDataset x;
final List<IDataset> ys;
if (ysIn == null) {
ys = new ArrayList<IDataset>(1);
ys.add(xIn);
x = DatasetFactory.createRange(DoubleDataset.class, ys.get(0).getSize());
x.setName("Index of " + xIn.getName());
} else {
x = xIn;
ys = (List<IDataset>) ysIn;
}
final StringBuilder buf = new StringBuilder();
buf.append("Plot of ");
final Set<String> used = new HashSet<String>(7);
int i = 0;
int dataSetSize = ys.size();
for (IDataset dataSet : ys) {
String name = getName(dataSet, rootName);
if (isFileName && name != null) {
// Strip off file name
final Matcher matcher = Pattern.compile("(.*) \\(.*\\)").matcher(name);
if (matcher.matches()) name = matcher.group(1);
}
if (used.contains(name)) continue;
if (i == 0) buf.append(name);
if (ys.size() < 2) break;
if (i == 1 && 1 == dataSetSize - 1) buf.append("," + name);
if (i == dataSetSize - 1 && dataSetSize - 1 != 1) buf.append("..." + name);
i++;
}
buf.append(" against ");
buf.append(x.getName());
return buf.toString();
}
/**
* - * @param axes specify real and imaginary coordinates as two 1d datasets
*
* @return a list containing a dataset of recursion limits
*/
@Override
public List<Dataset> value(IDataset... axes) {
Dataset xaxis, yaxis;
if (axes.length < 2) {
throw new IllegalArgumentException("Need two axes");
}
xaxis = DatasetUtils.convertToDataset(axes[0]);
yaxis = DatasetUtils.convertToDataset(axes[1]);
if (xaxis.getRank() != 1 || yaxis.getRank() != 1) {
throw new IllegalArgumentException("Need both axes to be 1d datasets");
}
IntegerDataset count =
DatasetFactory.zeros(IntegerDataset.class, yaxis.getShapeRef()[0], xaxis.getShapeRef()[0]);
List<Dataset> result = new ArrayList<Dataset>();
final IndexIterator iy = yaxis.getIterator();
int n = 0;
while (iy.hasNext()) {
final double iv = yaxis.getElementDoubleAbs(iy.index);
final IndexIterator ix = xaxis.getIterator();
while (ix.hasNext()) {
final double rv = xaxis.getElementDoubleAbs(ix.index);
double x = 0, y = 0;
int c = -1;
do {
double t = x * x - y * y + rv;
y = 2. * x * y + iv;
x = t;
} while (++c < maxRecursion && x * x + y * y <= 4.);
count.setAbs(n++, c);
}
}
result.add(count);
return result;
}
@Override
protected DataMessageComponent getTransformedMessage(List<DataMessageComponent> cache)
throws DataMessageException {
// get the data out of the message, name of the item should be specified
final Map<String, Serializable> data = MessageUtils.getList(cache);
Map<String, AFunction> functions;
try {
functions = MessageUtils.getFunctions(cache);
} catch (Exception e) {
throw new DataMessageException(
"Could not parse the Funcitons comming into the FunctionToDatsetActor", null, e);
}
// prepare the output message
DataMessageComponent result = MessageUtils.copy(cache);
// get the required datasets
String dataset = datasetName.getExpression();
String xAxis = xAxisName.getExpression();
String functionString = functionName.getExpression();
// Get the actual objects
Dataset xAxisDS = DatasetFactory.createFromObject(data.get(xAxis)).clone();
AFunction function = functions.get(functionString);
populateDataBasedFunctions(data, function);
// process the data
// TODO Add Null Protection here.
DoubleDataset createdDS = function.calculateValues(xAxisDS);
createdDS.setName(dataset);
// Add it to the result
result.addList(createdDS.getName(), createdDS);
return result;
}
/**
* Perform a two-dimensional interpolation
*
* @param oldx an IDataset containing a 1D array of X-values, sorted in increasing order,
* corresponding to the first dimension of <code>oldxy</code>
* @param oldy an IDataset containing a 1D array of Y-values, sorted in increasing order,
* corresponding to the second dimension of <code>oldxy</code>
* @param oldxy an IDataset containing a 2D grid of interpolation points
* @param newx an IDataset containing a 1D array of X-values that will be sent to the
* interpolating function
* @param newy an IDataset containing a 1D array of Y-values that will be sent to the
* interpolating function
* @param interpolator an instance of {@link
* org.apache.commons.math3.analysis.interpolation.BivariateGridInterpolator}
* @param output_type an {@link BicubicInterpolationOutput} that will determine how <code>newx
* </code> and <code>newy</code> will be interpreted, and therefore whether a 1D or 2D Dataset
* will be returned.
* @return rank 1 or 2 Dataset, depending on <code>output_type}</code>
* @throws NonMonotonicSequenceException
* @throws NumberIsTooSmallException
*/
public static Dataset interpolate(
IDataset oldx,
IDataset oldy,
IDataset oldxy,
IDataset newx,
IDataset newy,
BivariateGridInterpolator interpolator,
BicubicInterpolationOutput output_type)
throws NonMonotonicSequenceException, NumberIsTooSmallException {
// check shapes
if (oldx.getRank() != 1) throw new IllegalArgumentException("oldx Shape must be 1D");
if (oldy.getRank() != 1) throw new IllegalArgumentException("oldy Shape must be 1D");
if (oldxy.getRank() != 2) throw new IllegalArgumentException("oldxy Shape must be 2D");
if (oldx.getShape()[0] != oldxy.getShape()[0])
throw new IllegalArgumentException("oldx Shape must match oldxy Shape[0]");
if (oldy.getShape()[0] != oldxy.getShape()[1])
throw new IllegalArgumentException("oldy Shape must match oldxy Shape[1]");
if (newx.getRank() != 1) throw new IllegalArgumentException("newx Shape must be 1D");
if (newy.getRank() != 1) throw new IllegalArgumentException("newx Shape must be 1D");
if (output_type == BicubicInterpolationOutput.ONED && newy.getSize() != newx.getSize())
throw new IllegalArgumentException(
"newx and newy Size must be identical when expecting a rank 1 dataset result");
DoubleDataset oldx_dd = (DoubleDataset) DatasetUtils.cast(oldx, Dataset.FLOAT64);
DoubleDataset oldy_dd = (DoubleDataset) DatasetUtils.cast(oldy, Dataset.FLOAT64);
DoubleDataset oldxy_dd = (DoubleDataset) DatasetUtils.cast(oldxy, Dataset.FLOAT64);
// unlike in Interpolation1D, we will not be sorting here, as it just too complicated
// the user will be responsible for ensuring the arrays are properly sorted
// oldxy_dd needs to be transformed into a double[][] array
// this call may throw an exception that needs handling by the calling method
BivariateFunction func =
interpolator.interpolate(
oldx_dd.getData(), oldy_dd.getData(), convertDoubleDataset2DtoPrimitive(oldxy_dd));
Dataset rv = null;
if (output_type == BicubicInterpolationOutput.ONED) {
rv = DatasetFactory.zeros(new int[] {newx.getSize()}, Dataset.FLOAT64);
for (int i = 0; i < newx.getSize(); i++) {
double val = 0.0;
try {
val = func.value(newx.getDouble(i), newy.getDouble(i));
rv.set(val, i);
} catch (OutOfRangeException e) {
rv.set(0.0, i);
}
}
} else if (output_type == BicubicInterpolationOutput.TWOD) {
rv = DatasetFactory.zeros(new int[] {newx.getSize(), newy.getSize()}, Dataset.FLOAT64);
for (int i = 0; i < newx.getSize(); i++) {
for (int j = 0; j < newy.getSize(); j++) {
double val = 0.0;
try {
val = func.value(newx.getDouble(i), newy.getDouble(j));
rv.set(val, i, j);
} catch (OutOfRangeException e) {
rv.set(0.0, i, j);
}
}
}
}
rv.setName(oldxy.getName() + "_interpolated");
return rv;
}
public void createDataset(int dType) {
image = DatasetFactory.zeros(pshape, dType);
count = DatasetFactory.zeros(pshape, Dataset.INT16);
}
@Test
public void testWriteNX() {
String filename = "/tmp/sample.nxs";
NexusFileBuilder builder = new DefaultNexusFileBuilder(filename);
NXsample nxample = sample.getNXsample(builder);
int nCompo = sample.getPhases().size();
assertEquals("NX name incorrect", sample.getName(), nxample.getNameScalar());
assertEquals(
"NX description incorrect",
sample.getName() + ", " + sample.getComposition() + ", " + sample.getShapeName(),
nxample.getDescriptionScalar());
assertEquals(
"NX component names incorrect",
DatasetFactory.createFromList(
sample.getPhases().stream().map(a -> a.getName()).collect(Collectors.toList())),
nxample.getComponent());
assertEquals(
"NX component formulae incorrect",
DatasetFactory.createFromObject(
sample
.getPhases()
.stream()
.map(a -> a.getComposition().getHallNotation(false))
.collect(Collectors.toList()),
nCompo,
1),
nxample.getChemical_formula());
assertEquals(
"NX formula weight incorrect",
DatasetFactory.createFromList(
sample
.getPhases()
.stream()
.map(a -> a.getComposition().getFormulaMass())
.collect(Collectors.toList())),
nxample.getDataset("chemical_formula_weight"));
// unit cell parameters...
assertEquals(
"NX unit cell volume incorrect",
DatasetFactory.createFromList(
sample
.getPhases()
.stream()
.map(a -> a.getUnitCellVolume())
.collect(Collectors.toList())),
nxample.getUnit_cell_volume());
assertEquals(
"NX unit cell class incorrect",
DatasetFactory.createFromList(
sample
.getPhases()
.stream()
.map(a -> a.getCrystalSystem().getName())
.collect(Collectors.toList())),
nxample.getUnit_cell_class());
assertEquals(
"NX unit cell space group incorrect",
DatasetFactory.createFromList(
sample
.getPhases()
.stream()
.map(a -> a.getSpaceGroup().getNumber() + ": " + a.getSpaceGroup().getName())
.collect(Collectors.toList())),
nxample.getUnit_cell_group());
assertEquals(
"NX theoretical densities incorrect",
DatasetFactory.createFromList(
sample.getPhases().stream().map(a -> a.getDensity()).collect(Collectors.toList())),
nxample.getDataset("theoretical_density"));
}
