From 72f7c18615995fcdb01c98e946b7518be134d232 Mon Sep 17 00:00:00 2001 From: gac-iss Date: Mon, 20 Jan 2020 09:59:53 +0100 Subject: [PATCH] --- .gitignore | 1 + nbactions.xml | 49 ++ pom.xml | 79 +++ src/main/assembly/src.xml | 29 ++ src/main/java/Scienta.java | 554 ++++++++++++++++++++ src/main/java/ScientaPanel.form | 700 +++++++++++++++++++++++++ src/main/java/ScientaPanel.java | 898 ++++++++++++++++++++++++++++++++ 7 files changed, 2310 insertions(+) create mode 100644 .gitignore create mode 100644 nbactions.xml create mode 100644 pom.xml create mode 100644 src/main/assembly/src.xml create mode 100644 src/main/java/Scienta.java create mode 100644 src/main/java/ScientaPanel.form create mode 100644 src/main/java/ScientaPanel.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a6f89c2 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/target/ \ No newline at end of file diff --git a/nbactions.xml b/nbactions.xml new file mode 100644 index 0000000..71f7d61 --- /dev/null +++ b/nbactions.xml @@ -0,0 +1,49 @@ + + + + run + + jar + + + process-classes + org.codehaus.mojo:exec-maven-plugin:1.2.1:exec + + + -classpath %classpath;C:\Users\gac-ISS\Dev\pshell\bin\pshell-1.14.0-fat.jar --add-opens java.base/jdk.internal.loader=ALL-UNNAMED ch.psi.pshell.ui.App -home=C:\Users\gac-ISS\Dev\pshell\home -pini + java + ../../home + + + + debug + + jar + + + process-classes + org.codehaus.mojo:exec-maven-plugin:1.2.1:exec + + + -agentlib:jdwp=transport=dt_socket,server=n,address=${jpda.address} -classpath %classpath;C:\Users\gac-ISS\Dev\pshell\bin\pshell-1.14.0-fat.jar --add-opens java.base/jdk.internal.loader=ALL-UNNAMED ch.psi.pshell.ui.App -home=C:\Users\gac-ISS\Dev\pshell\home -pini + java + true + ../../home + + + + profile + + jar + + + process-classes + org.codehaus.mojo:exec-maven-plugin:1.2.1:exec + + + -classpath %classpath;C:\Users\gac-ISS\Dev\pshell\bin\pshell-1.14.0-fat.jar --add-opens java.base/jdk.internal.loader=ALL-UNNAMED ch.psi.pshell.ui.App -home=C:\Users\gac-ISS\Dev\pshell\home -pini + java + ../../home + + + diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..fc4fa2e --- /dev/null +++ b/pom.xml @@ -0,0 +1,79 @@ + + + 4.0.0 + ch.psi + Scienta + 1.0 + jar + + UTF-8 + 1.8 + 1.8 + + + + jcenter + jcenter + https://jcenter.bintray.com/ + + + + freehep + freehep + http://java.freehep.org/maven2/ + + + + imagej + imagej + http://maven.imagej.net/content/repositories/public + + + + bintray-hltools + bintray + https://dl.bintray.com/paulscherrerinstitute/hltools + + + Scienta + + + ${project.groupId} + pshell + 1.14.0 + provided + + + + + + + maven-assembly-plugin + + + src/main/assembly/src.xml + + + + ../../home/extensions + + + + + make-assembly + package + + single + + + + + + + + \ No newline at end of file diff --git a/src/main/assembly/src.xml b/src/main/assembly/src.xml new file mode 100644 index 0000000..0dd2b05 --- /dev/null +++ b/src/main/assembly/src.xml @@ -0,0 +1,29 @@ + + + + + + jar-with-dependencies + + jar + + false + + + + false + + / + true + true + runtime + + + + + + diff --git a/src/main/java/Scienta.java b/src/main/java/Scienta.java new file mode 100644 index 0000000..e4018c2 --- /dev/null +++ b/src/main/java/Scienta.java @@ -0,0 +1,554 @@ + +import ch.psi.pshell.device.AccessType; +import ch.psi.pshell.device.ArrayCalibration; +import ch.psi.pshell.device.CameraImageDescriptor; +import ch.psi.pshell.device.MatrixCalibration; +import ch.psi.pshell.device.Device; +import ch.psi.pshell.device.DeviceAdapter; +import ch.psi.pshell.device.Readable.ReadableCalibratedArray; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import ch.psi.pshell.epics.*; + +/** + * Implementation of Scienta spectrometer analyser. + */ +public class Scienta extends AreaDetector { + + final ChannelInteger slices, frames; + final ChannelDouble lowEnergy, centerEnergy, highEnergy, stepSize, stepTime, energyWidth; + final ChannelDoubleArray spectrum, image, extio; + final ChannelDouble currentChannel, totalPoints; + final ChannelDouble channelBegin, channelEnd, sliceBegin, sliceEnd; + final ChannelString lensMode, acquisitionMode, passEnergy; + final ChannelInteger numChannels, numSlices; + final ChannelDouble acquisitionTime; + final Stats[] stats; + final String channelCtrl; + + public Scienta(final String name, final String channelPrefix) { + this(name, channelPrefix + ":cam1", channelPrefix + ":image1"); + } + + public Scienta(String name, String channelCtrl, String channelData) { + super(name, channelCtrl, channelData); + this.channelCtrl = channelCtrl; + slices = new ChannelInteger(name + " slices", channelCtrl + ":SLICES", false); + frames = new ChannelInteger(name + " frames", channelCtrl + ":FRAMES", false); + + lowEnergy = new ChannelDouble(name + " low energy", channelCtrl + ":LOW_ENERGY", 3, false); + centerEnergy = new ChannelDouble(name + " center energy", channelCtrl + ":CENTRE_ENERGY", 3, false); + highEnergy = new ChannelDouble(name + " high energy", channelCtrl + ":HIGH_ENERGY", 3, false); + stepSize = new ChannelDouble(name + " step size", channelCtrl + ":STEP_SIZE", 3, false); + stepTime = new ChannelDouble(name + " step time", channelCtrl + ":STEP_TIME", 3, false); + + energyWidth = new ChannelDouble(name + " energy width", channelCtrl + ":ENERGY_WIDTH_RBV", 3, false); + energyWidth.setAccessType(AccessType.Read); + passEnergy = new ChannelString(name + " pass energy", channelCtrl + ":PASS_ENERGY", false); + lensMode = new ChannelString(name + " lens mode", channelCtrl + ":LENS_MODE", false); + acquisitionMode = new ChannelString(name + " lens mode", channelCtrl + ":ACQ_MODE", false); + channelBegin = new ChannelDouble(name + " channel begin", channelCtrl + ":CHANNEL_BEGIN_RBV", 3, false); + channelBegin.setAccessType(AccessType.Read); + channelEnd = new ChannelDouble(name + " channel end", channelCtrl + ":CHANNEL_END_RBV", 3, false); + channelEnd.setAccessType(AccessType.Read); + sliceBegin = new ChannelDouble(name + " slice begin", channelCtrl + ":SLICE_BEGIN_RBV", 3, false); + sliceBegin.setAccessType(AccessType.Read); + sliceEnd = new ChannelDouble(name + " slice end", channelCtrl + ":SLICE_END_RBV", 3, false); + sliceEnd.setAccessType(AccessType.Read); + numChannels = new ChannelInteger(name + " num channels", channelCtrl + ":NUM_CHANNELS_RBV", false); + numChannels.setAccessType(AccessType.Read); + numSlices = new ChannelInteger(name + " num slices", channelCtrl + ":SLICES_RBV", false); + numSlices.setAccessType(AccessType.Read); + numChannels.addListener(new DeviceAdapter() { + @Override + public void onValueChanged(Device device, Object value, Object former) { + try { + if (value != null) { + spectrum.setSize((Integer) value); + } + } catch (IOException ex) { + getLogger().log(Level.WARNING, null, ex); + } + } + }); + acquisitionTime = new ChannelDouble(name + " acquire time", channelCtrl + ":TOTAL_ACQ_TIME_RBV", 3, false); + acquisitionTime.setAccessType(AccessType.Read); + + + /* + spectrum = new ChannelDoubleArray(name + " spectrum", channelCtrl + ":INT_SPECTRUM", 8, 200, false) { + @Override + protected double[] doRead() throws IOException, InterruptedException { + numChannels.getValue(); + return super.doRead(); + } + }; + spectrum.setAccessType(AccessType.Read); + */ + spectrum = new ScientaSpectrum(); + image = new ChannelDoubleArray(name + " image", channelCtrl + ":IMAGE", 8, -1, false); + image.setAccessType(AccessType.Read); + extio = new ChannelDoubleArray(name + " extio", channelCtrl + ":EXTIO", 8, -1, false); + extio.setAccessType(AccessType.Read); + + currentChannel = new ChannelDouble(name + " current channel", channelCtrl + ":CURRENT_CHANNEL_RBV", 0, false); + currentChannel.setAccessType(AccessType.Read); + totalPoints = new ChannelDouble(name + " total points", channelCtrl + ":TOTAL_POINTS_RBV", 0, false); + totalPoints.setAccessType(AccessType.Read); + + addChildren(new Device[]{slices, frames, + lowEnergy, centerEnergy, highEnergy, stepSize, stepTime, energyWidth, + spectrum, image, extio, + currentChannel, totalPoints, + channelBegin, channelEnd, sliceBegin, sliceEnd, + passEnergy, lensMode, acquisitionMode, + numChannels, numSlices, acquisitionTime + }); + + stats = new Stats[5]; + stats[0] = new Stats("CountsR1", 1); + stats[1] = new Stats("CountsR2", 2); + stats[2] = new Stats("CountsR3", 3); + stats[3] = new Stats("CountsR4", 4); + stats[4] = new Stats("Counts", 5); + addChildren(stats); + } + + public class ScientaSpectrum extends ChannelDoubleArray implements ReadableCalibratedArray { + + ScientaSpectrum() { + super(Scienta.this.getName() + " spectrum", channelCtrl + ":INT_SPECTRUM", 8, 200, false); + setAccessType(AccessType.Read); + } + + @Override + protected double[] doRead() throws IOException, InterruptedException { + numChannels.getValue(); + return super.doRead(); + } + + @Override + public ArrayCalibration getCalibration() { + double scale = 1.0; + double offset = 0.0; + try { + List channelRange = getChannelRange(); + Double cb = channelRange.get(0); + Double ce = channelRange.get(1); + scale = (ce - cb) / Math.max(numChannels.getValue() - 1, 1); + offset = cb; + } catch (Exception ex) { + } + return new ArrayCalibration(scale, offset); + } + } + + @Override + protected void doSetSimulated() { + super.doSetSimulated(); + setCache(channelBegin, 50.0); + setCache(channelEnd, 150.0); + setCache(sliceBegin, -20.0); + setCache(sliceEnd, 20.0); + setCache(numChannels, 100); + setCache(numSlices, 10); + setCache(spectrum, new double[100]); + setCache(currentChannel, 0.0); + setCache(totalPoints, 100.0); + setCache(passEnergy, String.valueOf(PASS_ENERGY_VALUES[0])); + setCache(lensMode, LensMode.Transmission.toString()); + setCache(acquisitionMode, AcquisitionMode.Fixed.toString()); + setCache(acquisitionTime, 10.0); + + setSimulatedValue("ENERGY_MODE", EnergyMode.Binding.toString()); + setSimulatedValue("DETECTOR_MODE", DetectorMode.Pulse_Counting.toString()); + setSimulatedValue("ELEMENT_SET", ElementSet.R4000HE.toString()); + //setSimulatedValue("ACQ_MODE", AcquisitionMode.Fixed.toString()); + //setSimulatedValue("LENS_MODE", LensMode.Angular45.toString()); + //setSimulatedValue("PASS_ENERGY", String.valueOf(PASS_ENERGY_VALUES[0])); + + } + + @Override + protected void doUpdate() throws IOException, InterruptedException { + super.doUpdate(); + numChannels.update(); + currentChannel.update(); + slices.update(); + lowEnergy.update(); + centerEnergy.update(); + highEnergy.update(); + energyWidth.update(); + stepSize.update(); + stepTime.update(); + totalPoints.update(); + passEnergy.update(); + lensMode.update(); + acquisitionMode.update(); + acquisitionTime.update(); + //channelBegin.update(); + //channelEnd.update(); + ///sliceBegin.update(); + //sliceEnd.update(); + } + + @Override + protected void doSetMonitored(boolean value) { + super.doSetMonitored(value); + numChannels.setMonitored(value); + currentChannel.setMonitored(value); + slices.setMonitored(value); + lowEnergy.setMonitored(value); + centerEnergy.setMonitored(value); + highEnergy.setMonitored(value); + energyWidth.setMonitored(value); + stepSize.setMonitored(value); + stepTime.setMonitored(value); + totalPoints.setMonitored(value); + passEnergy.setMonitored(value); + lensMode.setMonitored(value); + acquisitionMode.setMonitored(value); + acquisitionTime.setMonitored(value); + //channelBegin.setMonitored(value); + //channelEnd.setMonitored(value); + //sliceBegin.setMonitored(value); + //sliceEnd.setMonitored(value); + } + + @Override + protected CameraImageDescriptor doReadImageDescriptor() throws IOException, InterruptedException { + CameraImageDescriptor ret = super.doReadImageDescriptor(); + List channelRange = getChannelRange(); + List sliceRange = getSliceRange(); + + Double cb = channelRange.get(0); + Double ce = channelRange.get(1); + Double sb = sliceRange.get(0); + Double se = sliceRange.get(1); + + if ((cb == null) || (ce == null) || (sb == null) || (se == null) || (ret.width == 0) || (ret.height == 0)) { + ret.calibration = null; + } else { + double scaleX = (ce - cb) / Math.max(ret.width - 1, 1); + double offsetX = cb; + double scaleY = (se - sb) / Math.max(ret.height - 1, 1); + double offsetY = sb; + + ret.calibration = new MatrixCalibration(scaleX, scaleY, offsetX, offsetY); + } + return ret; + } + + //Modes + public enum AcquisitionMode { + + Swept, + Fixed + } + + public void setAcquisitionMode(AcquisitionMode mode) throws IOException, InterruptedException { + //writeCtrlEnum("ACQ_MODE", String.valueOf(mode)); + acquisitionMode.write(String.valueOf(mode)); + } + + public AcquisitionMode getAcquisitionMode() throws IOException, InterruptedException { + //return (AcquisitionMode) readCtrlEnum("ACQ_MODE", AcquisitionMode.class); + String val = acquisitionMode.getValue(); + return (AcquisitionMode) convertCtrlEnum(val, AcquisitionMode.class); + } + + public enum EnergyMode { + + Binding, + Kinetic + } + + public void setEnergyMode(EnergyMode mode) throws IOException, InterruptedException { + writeCtrlEnum("ENERGY_MODE", String.valueOf(mode)); + } + + public EnergyMode getEnergyMode() throws IOException, InterruptedException { + return (EnergyMode) readCtrlEnum("ENERGY_MODE", EnergyMode.class); + } + + public enum LensMode { + + Transmission, + T_HiPPHAXPES, + A_HiPPHAXPES, + Jet_X12, + Jet_X5, + A_HiPP_0p52, + Jet_X8,//(floating), + Ztest + } + + public void setLensMode(LensMode mode) throws IOException, InterruptedException { + //writeCtrlEnum("LENS_MODE", String.valueOf(mode)); + lensMode.write(mode.equals(LensMode.Jet_X8) ? "Jet_X8(floating)" : String.valueOf(mode)); + } + + public LensMode getLensMode() throws IOException, InterruptedException { + //return (LensMode) readCtrlEnum("LENS_MODE", LensMode.class); + String val = lensMode.getValue(); + return "Jet_X8(floating)".equals(val) ? LensMode.Jet_X8 : convertCtrlEnum(val, LensMode.class); + } + + public enum DetectorMode { + + Pulse_Counting, + ADC + } + + public void setDetectorMode(DetectorMode mode) throws IOException, InterruptedException { + writeCtrlEnum("DETECTOR_MODE", String.valueOf(mode)); + } + + public DetectorMode getDetectorMode() throws IOException, InterruptedException { + return (DetectorMode) readCtrlEnum("DETECTOR_MODE", DetectorMode.class); + } + + public enum ElementSet { + + R4000HE, + HiPPHAXPES, + HiPP_Acc + } + + public void setElementSet(ElementSet mode) throws IOException, InterruptedException { + writeCtrlEnum("ELEMENT_SET", String.valueOf(mode)); + } + + public ElementSet getElementSet() throws IOException, InterruptedException { + return (ElementSet) readCtrlEnum("ELEMENT_SET", ElementSet.class); + } + + public static final int[] PASS_ENERGY_VALUES = new int[]{2, 5, 10, 20, 50, 100, 200}; + + public void setPassEnergy(int energy) throws IOException, InterruptedException { + //writeCtrl("PASS_ENERGY", String.valueOf(energy)); + passEnergy.write(String.valueOf(energy)); + + } + + public int getPassEnergy() throws IOException, InterruptedException { + //String ret = (String) readCtrl("PASS_ENERGY", String.class); + String ret = passEnergy.getValue(); + try { + return Integer.valueOf(ret); + } catch (Exception ex) { + throw new DeviceInvalidParameterException("Pass Energy", ret); + } + } + + public void zeroSupplies() throws IOException, InterruptedException { + writeCtrl("ZERO_SUPPLIES", 1); + } + + //Progress + //Disconnected operations + public double getProgress() { + Double cur = currentChannel.take(); + Double total = totalPoints.take(); + if ((cur == null) || (total == null) || (total == 0)) { + return 0.0; + } + return cur / total; + } + + public double[] getSpectrumX() throws IOException, InterruptedException { + List range = getChannelRange(); + Double begin = range.get(0); + Double end = range.get(1); + double[] spectrum = getSpectrum().take(); + if ((begin == null) || (end == null) || (spectrum == null)) { + return null; + } + int spectrumSize = spectrum.length; + double step = (end - begin) / (spectrumSize - 1); + double[] x = new double[spectrumSize]; + for (int i = 0; i < spectrumSize; i++) { + x[i] = begin + step * i; + } + return x; + } + + //Direct register access + public ChannelInteger getSlices() { + return slices; + } + + public ChannelInteger getFrames() { + return frames; + } + + public ChannelDouble getLowEnergy() { + return lowEnergy; + } + + public ChannelDouble getCenterEnergy() { + return centerEnergy; + } + + public ChannelDouble getHighEnergy() { + return highEnergy; + } + + public ChannelDouble getStepSize() { + return stepSize; + } + + public ChannelDouble getStepTime() { + return stepTime; + } + + public ChannelDouble getEnergyWidth() { + return energyWidth; + } + + public ChannelDoubleArray getSpectrum() { + return spectrum; + } + + public ChannelDoubleArray getImage() { + return image; + } + + public ChannelDoubleArray getExtio() { + return extio; + } + + public ChannelDouble getChannelBegin() { + return channelBegin; + } + + public ChannelDouble getChannelEnd() { + return channelEnd; + } + + public ChannelDouble getSliceBegin() { + return sliceBegin; + } + + public ChannelDouble getSliceEnd() { + return sliceEnd; + } + + public ChannelDouble getAcquisitionTime() { + return acquisitionTime; + } + + public List getChannelRange() throws IOException, InterruptedException { + ArrayList ret = new ArrayList<>(); + //ret.add(getChannelBegin().getValue()); + //ret.add(getChannelEnd().getValue()); + switch (getAcquisitionMode()) { + case Swept: + ret.add(lowEnergy.getValue()); + ret.add(highEnergy.getValue()); + break; + case Fixed: + default: + double eCenter = centerEnergy.getValue(); + int ePass = getPassEnergy(); + double xe = 0.04464; + double xn = 0.04464; + ret.add(eCenter - xe * ePass); + ret.add(eCenter + xn * ePass); + break; + + } + return ret; + } + + public List getSliceRange() throws IOException, InterruptedException { + ArrayList ret = new ArrayList<>(); + //ret.add(sliceBegin.getValue()); + //ret.add(sliceEnd.getValue()); + try { + switch (getLensMode()) { + //TODO: + /* + case Angular45: + ret.add(-28.148); + ret.add(27.649); + break; + case Angular60: + ret.add(-34.736); + ret.add(34.119); + break; + */ + case Transmission: + default: + ret.add(-2.332); + ret.add(2.291); + break; + + } + } catch (Exception ex) { + ret.add(Double.NaN); + ret.add(Double.NaN); + } + return ret; + } + + public ChannelInteger getNumChannels() { + return numChannels; + } + + public ChannelInteger getNumSlices() { + return numSlices; + } + + public ChannelDouble getTotalChannels() { + return totalPoints; + } + + public ChannelDouble getCurrentChannel() { + return currentChannel; + } + + public Stats[] getStats() { + return stats; + } + + public class Stats extends ChannelDouble { + + final int index; + final ChannelInteger uid; + + Stats(String name, int index) { + super(name, channelCtrl.split(":")[0] + ":Stats" + index + ":Total_RBV", 3, false); + this.index = index; + uid = new ChannelInteger(name + " uid", channelCtrl.split(":")[0] + ":Stats" + index + ":UniqueId_RBV", false); + //setParent(Scienta.this); + addChild(uid); + } + + @Override + public boolean isReady() throws IOException, InterruptedException { + Integer imageCounter = getImageCounter().getValue(); + if (imageCounter == null) { + return false; + } + Integer id = uid.take(); + if ((id == null) || (!imageCounter.equals(id))) { + uid.update(); + } + return imageCounter.equals(uid.take()); + } + + @Override + public Double read() throws IOException, InterruptedException { + assertInitialized(); + waitReady(10000); + return super.read(); + } + + public int getUID() throws IOException, InterruptedException { + return uid.getValue(); + } + } +} diff --git a/src/main/java/ScientaPanel.form b/src/main/java/ScientaPanel.form new file mode 100644 index 0000000..1a1c004 --- /dev/null +++ b/src/main/java/ScientaPanel.form @@ -0,0 +1,700 @@ + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
diff --git a/src/main/java/ScientaPanel.java b/src/main/java/ScientaPanel.java new file mode 100644 index 0000000..a5475d0 --- /dev/null +++ b/src/main/java/ScientaPanel.java @@ -0,0 +1,898 @@ +import ch.psi.pshell.device.Device; +import ch.psi.pshell.device.DeviceAdapter; +import ch.psi.pshell.device.DeviceListener; + + +import ch.psi.pshell.plot.LinePlotSeries; +import ch.psi.pshell.plot.Plot; +import ch.psi.utils.State; +import ch.psi.utils.swing.SwingUtils; +import java.awt.Component; +import java.io.IOException; +import java.util.logging.Level; +import javax.swing.DefaultComboBoxModel; +import javax.swing.JComboBox; +import javax.swing.SwingUtilities; + +import ch.psi.pshell.swing.*; +/** + * + */ +public final class ScientaPanel extends DevicePanel { + + LinePlotSeries spectrumSeries; + + public ScientaPanel() { + initComponents(); + spectrumSeries = new LinePlotSeries("intensity"); + plot.getAxis(Plot.AxisId.X).setLabel("Channels"); + plot.getAxis(Plot.AxisId.Y).setLabel("Intensity"); + plot.addSeries(spectrumSeries); + plot.setUpdatesEnabled(false); + //plot.getAxis(Plot.AxisId.X).setRange(-0.1, 50000.1); + //plot.getAxis(Plot.AxisId.Y).setRange(-0.6, 0.6); + plot.setQuality(Plot.Quality.Low); + + ValueSelection.ValueSelectionListener valueListener = (ValueSelection origin, double value, boolean editing) -> { + if (editing) { + try { + if (origin == valueLow) { + getDevice().getLowEnergy().writeAsync(value); + } else if (origin == valueCenter) { + getDevice().getCenterEnergy().writeAsync(value); + } else if (origin == valueHigh) { + getDevice().getHighEnergy().writeAsync(value); + } else if (origin == valueTime) { + getDevice().getStepTime().writeAsync(value); + } else if (origin == valueSize) { + getDevice().getStepSize().writeAsync(value); + } else if (origin == valueSlices) { + getDevice().getSlices().writeAsync((int) value); + } else if (origin == valueIterations) { + getDevice().setIterations((int) value); + }/*else if (origin == valueFrames) { + getDevice().getFrames().writeAsync((int) value); + }*/ + + } catch (Exception ex) { + showException(ex); + } + } + }; + + for (Component vs : SwingUtils.getComponentsByType(this, ValueSelection.class)) { + if (((ValueSelection) vs).isEnabled()) { + ((ValueSelection) vs).addListener(valueListener); + } + } + SwingUtils.setEnumCombo(comboLens, Scienta.LensMode.class); + SwingUtils.setEnumCombo(comboElement, Scienta.ElementSet.class); + SwingUtils.setEnumCombo(comboAcquisition, Scienta.AcquisitionMode.class); + SwingUtils.setEnumCombo(comboEnergy, Scienta.EnergyMode.class); + SwingUtils.setEnumCombo(comboDetector, Scienta.DetectorMode.class); + + DefaultComboBoxModel model = new DefaultComboBoxModel(); + for (Integer energy : Scienta.PASS_ENERGY_VALUES) { + model.addElement(energy); + } + comboPass.setModel(model); + } + + public boolean getShowCameraPanel() { + return cameraPanel.isVisible(); + } + + public void setShowCameraPanel(boolean value) { + cameraPanel.setVisible(value); + } + + public boolean getShowSpectrum() { + return plotSpectrum.isVisible(); + } + + public void setShowSpectrum(boolean value) { + plotSpectrum.setVisible(value); + } + + @Override + public Scienta getDevice() { + return (Scienta) super.getDevice(); + } + + @Override + public void setDevice(Device device) { + if (getDevice() != null) { + getDevice().getCurrentChannel().removeListener(progressListener); + } + super.setDevice(device); + cameraPanel.setDevice(device); + if (device == null) { + stopTimer(); + } else { + getDevice().getCurrentChannel().addListener(progressListener); + getDevice().getSpectrum().addListener(spectrumListener); + //cameraPanel.startTimer(3000, 0); + startTimer(3000, 0); + } + } + + DeviceListener progressListener = new DeviceAdapter() { + @Override + public void onValueChanged(final Device device, final Object value, final Object former) { + SwingUtilities.invokeLater(() -> { + valueCurrent.setValue((Double) value); + progress.setValue((int) (getDevice().getProgress() * 1000)); + }); + } + }; + + DeviceListener spectrumListener = new DeviceAdapter() { + @Override + public void onValueChanged(final Device device, final Object value, final Object former) { + SwingUtilities.invokeLater(() -> { + updateSpectrum(); + }); + } + }; + + @Override + protected void onHide() { + super.onHide(); + } + + @Override + protected void onTimer() { + startBackgroundUpdate(); + } + + //Callbacks + @Override + protected void onDeviceStateChanged(State state, State former) { + } + + @Override + protected void onDeviceValueChanged(Object state, Object former) { + } + + public class DeviceData { + + double[] spectrum; + Scienta.LensMode lensMode; + Scienta.ElementSet elementSet; + Scienta.AcquisitionMode acquisitionMode; + Scienta.EnergyMode energyMode; + Scienta.DetectorMode detectorMode; + double low; + double center; + double high; + double width; + //int frames; + double time; + double size; + int slices; + int pass; + int iterations; + + int current; + int total; + } + + @Override + protected DeviceData doBackgroundUpdate() throws IOException, InterruptedException { + DeviceData dd = new DeviceData(); + //read-once + + dd.spectrum = getDevice().getSpectrum().getValue(); + + dd.lensMode = getDevice().getLensMode(); + dd.elementSet = getDevice().getElementSet(); + dd.acquisitionMode = getDevice().getAcquisitionMode(); + dd.energyMode = getDevice().getEnergyMode(); + dd.detectorMode = getDevice().getDetectorMode(); + dd.pass = getDevice().getPassEnergy(); + + dd.low = getDevice().getLowEnergy().getValue(); + dd.center = getDevice().getCenterEnergy().getValue(); + dd.high = getDevice().getHighEnergy().getValue(); + dd.width = getDevice().getEnergyWidth().getValue(); + //dd.frames = getDevice().getFrames().getValue(); + dd.time = getDevice().getStepTime().getValue(); + dd.size = getDevice().getStepSize().getValue(); + dd.slices = getDevice().getSlices().getValue(); + + dd.current = getDevice().getCurrentChannel().getValue().intValue(); + dd.total = getDevice().getTotalChannels().getValue().intValue(); + dd.iterations = getDevice().getIterations(); + return dd; + } + + void updateValueField(ValueSelection field, double value) { + try { + field.setValue(value); + } catch (Exception ex) { + getLogger().log(Level.FINE, null, ex); + } + } + + void updateComboField(JComboBox field, Object value) { + try { + if (field.getSelectedItem() != value) { + field.setSelectedItem(value); + } + } catch (Exception ex) { + getLogger().log(Level.FINE, null, ex); + } + } + + @Override + protected void onBackgroundUpdateFinished(Object data) { + DeviceData dd = (DeviceData) data; + + updateSpectrum(); + + updateValueField(valueLow, dd.low); + updateValueField(valueCenter, dd.center); + updateValueField(valueHigh, dd.high); + updateValueField(valueWidth, dd.width); + //updateValue(valueFrames, dd.frames); + updateValueField(valueTime, dd.time); + updateValueField(valueSize, dd.size); + updateValueField(valueSlices, dd.slices); + updateValueField(valueIterations, dd.iterations); + updateValueField(valueTotal, dd.total); + updateValueField(valueCurrent, dd.current); + + updateComboField(comboLens, dd.lensMode); + updateComboField(comboAcquisition, dd.acquisitionMode); + updateComboField(comboDetector, dd.detectorMode); + updateComboField(comboEnergy, dd.energyMode); + updateComboField(comboElement, dd.elementSet); + updateComboField(comboPass, dd.pass); + + try { + progress.setValue((int) (getDevice().getProgress() * 1000)); + } catch (Exception ex) { + getLogger().log(Level.FINE, null, ex); + } + } + + void updateSpectrum() { + try { + double[] xSpectrum = getDevice().getSpectrumX(); + if (xSpectrum != null) { + spectrumSeries.setData(xSpectrum, getDevice().getSpectrum().take()); + plot.updateSeries(spectrumSeries); + return; + } + } catch (Exception ex) { + getLogger().log(Level.FINE, null, ex); + } + spectrumSeries.clear(); + } + + /** + * This method is called from within the constructor to initialize the form. WARNING: Do NOT + * modify this code. The content of this method is always regenerated by the Form Editor. + */ + @SuppressWarnings("unchecked") + // //GEN-BEGIN:initComponents + private void initComponents() { + + cameraPanel = new ch.psi.pshell.swing.CameraPanel(); + scientaPanel = new javax.swing.JPanel(); + jPanel5 = new javax.swing.JPanel(); + progress = new javax.swing.JProgressBar(); + jLabel6 = new javax.swing.JLabel(); + valueCurrent = new ch.psi.pshell.swing.ValueSelection(); + jLabel16 = new javax.swing.JLabel(); + valueTotal = new ch.psi.pshell.swing.ValueSelection(); + plotSpectrum = new javax.swing.JPanel(); + plot = new ch.psi.pshell.plot.LinePlotJFree(); + jPanel6 = new javax.swing.JPanel(); + jPanel1 = new javax.swing.JPanel(); + jLabel1 = new javax.swing.JLabel(); + comboLens = new javax.swing.JComboBox(); + jLabel2 = new javax.swing.JLabel(); + comboAcquisition = new javax.swing.JComboBox(); + jLabel3 = new javax.swing.JLabel(); + comboEnergy = new javax.swing.JComboBox(); + jLabel4 = new javax.swing.JLabel(); + comboDetector = new javax.swing.JComboBox(); + jLabel5 = new javax.swing.JLabel(); + comboElement = new javax.swing.JComboBox(); + jPanel4 = new javax.swing.JPanel(); + jLabel11 = new javax.swing.JLabel(); + comboPass = new javax.swing.JComboBox(); + jLabel12 = new javax.swing.JLabel(); + valueLow = new ch.psi.pshell.swing.ValueSelection(); + jLabel13 = new javax.swing.JLabel(); + valueCenter = new ch.psi.pshell.swing.ValueSelection(); + jLabel14 = new javax.swing.JLabel(); + valueHigh = new ch.psi.pshell.swing.ValueSelection(); + jLabel15 = new javax.swing.JLabel(); + valueWidth = new ch.psi.pshell.swing.ValueSelection(); + jPanel2 = new javax.swing.JPanel(); + jLabel8 = new javax.swing.JLabel(); + valueTime = new ch.psi.pshell.swing.ValueSelection(); + jLabel9 = new javax.swing.JLabel(); + valueSize = new ch.psi.pshell.swing.ValueSelection(); + jLabel10 = new javax.swing.JLabel(); + valueSlices = new ch.psi.pshell.swing.ValueSelection(); + jLabel17 = new javax.swing.JLabel(); + valueIterations = new ch.psi.pshell.swing.ValueSelection(); + buttonZeroSupplies = new javax.swing.JButton(); + + cameraPanel.setBorder(null); + + jPanel5.setBorder(javax.swing.BorderFactory.createTitledBorder("Progress")); + + progress.setMaximum(1000); + + jLabel6.setText("Current point:"); + + valueCurrent.setDecimals(0); + valueCurrent.setEnabled(false); + valueCurrent.setMaxValue(100000.0); + valueCurrent.setMinValue(0.0); + valueCurrent.setShowButtons(false); + + jLabel16.setText("Total:"); + + valueTotal.setDecimals(0); + valueTotal.setEnabled(false); + valueTotal.setMaxValue(100000.0); + valueTotal.setMinValue(0.0); + valueTotal.setShowButtons(false); + + javax.swing.GroupLayout jPanel5Layout = new javax.swing.GroupLayout(jPanel5); + jPanel5.setLayout(jPanel5Layout); + jPanel5Layout.setHorizontalGroup( + jPanel5Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel5Layout.createSequentialGroup() + .addContainerGap() + .addComponent(jLabel6) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addComponent(valueCurrent, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addGap(18, 18, 18) + .addComponent(jLabel16) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addComponent(valueTotal, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addGap(18, 18, 18) + .addComponent(progress, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE) + .addContainerGap()) + ); + jPanel5Layout.setVerticalGroup( + jPanel5Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel5Layout.createSequentialGroup() + .addGap(4, 4, 4) + .addGroup(jPanel5Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) + .addComponent(jLabel6) + .addComponent(valueCurrent, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(valueTotal, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(progress, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(jLabel16)) + .addGap(4, 4, 4)) + ); + + plotSpectrum.setBorder(javax.swing.BorderFactory.createTitledBorder("Spectrum")); + + plot.setTitle(""); + + javax.swing.GroupLayout plotSpectrumLayout = new javax.swing.GroupLayout(plotSpectrum); + plotSpectrum.setLayout(plotSpectrumLayout); + plotSpectrumLayout.setHorizontalGroup( + plotSpectrumLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(plotSpectrumLayout.createSequentialGroup() + .addGap(0, 0, 0) + .addComponent(plot, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE)) + ); + plotSpectrumLayout.setVerticalGroup( + plotSpectrumLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(plotSpectrumLayout.createSequentialGroup() + .addGap(0, 0, 0) + .addComponent(plot, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + .addGap(0, 0, 0)) + ); + + jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Modes")); + + jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel1.setText("Lens:"); + + comboLens.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Item 1", "Item 2", "Item 3", "Item 4" })); + comboLens.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + comboLensActionPerformed(evt); + } + }); + + jLabel2.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel2.setText("Acquisition:"); + + comboAcquisition.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Item 1", "Item 2", "Item 3", "Item 4" })); + comboAcquisition.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + comboAcquisitionActionPerformed(evt); + } + }); + + jLabel3.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel3.setText("Energy:"); + + comboEnergy.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Item 1", "Item 2", "Item 3", "Item 4" })); + comboEnergy.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + comboEnergyActionPerformed(evt); + } + }); + + jLabel4.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel4.setText("Detector:"); + + comboDetector.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Item 1", "Item 2", "Item 3", "Item 4" })); + comboDetector.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + comboDetectorActionPerformed(evt); + } + }); + + jLabel5.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel5.setText("Element:"); + + comboElement.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Item 1", "Item 2", "Item 3", "Item 4" })); + comboElement.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + comboElementActionPerformed(evt); + } + }); + + javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1); + jPanel1.setLayout(jPanel1Layout); + jPanel1Layout.setHorizontalGroup( + jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel1Layout.createSequentialGroup() + .addContainerGap() + .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jLabel5) + .addComponent(jLabel4) + .addComponent(jLabel3) + .addComponent(jLabel2) + .addComponent(jLabel1)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(comboLens, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(comboAcquisition, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(comboElement, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(comboDetector, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(comboEnergy, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addContainerGap()) + ); + + jPanel1Layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {jLabel1, jLabel2, jLabel3, jLabel4, jLabel5}); + + jPanel1Layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {comboAcquisition, comboDetector, comboElement, comboEnergy, comboLens}); + + jPanel1Layout.setVerticalGroup( + jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel1Layout.createSequentialGroup() + .addContainerGap() + .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) + .addComponent(jLabel1) + .addComponent(comboLens, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) + .addComponent(jLabel2) + .addComponent(comboAcquisition, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) + .addComponent(jLabel3) + .addComponent(comboEnergy, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) + .addComponent(jLabel4) + .addComponent(comboDetector, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) + .addComponent(jLabel5) + .addComponent(comboElement, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addContainerGap(17, Short.MAX_VALUE)) + ); + + jPanel4.setBorder(javax.swing.BorderFactory.createTitledBorder("Energy")); + + jLabel11.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel11.setText("Pass:"); + + comboPass.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "2", "5", "10", "20", "50", "100", "200" })); + comboPass.setToolTipText(""); + comboPass.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + comboPassActionPerformed(evt); + } + }); + + jLabel12.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel12.setText("Low:"); + + valueLow.setDecimals(2); + valueLow.setMaxValue(2000.0); + valueLow.setMinValue(0.0); + valueLow.setShowButtons(false); + + jLabel13.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel13.setText("Center:"); + + valueCenter.setDecimals(2); + valueCenter.setMaxValue(2000.0); + valueCenter.setMinValue(0.0); + valueCenter.setShowButtons(false); + + jLabel14.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel14.setText("High:"); + + valueHigh.setDecimals(2); + valueHigh.setMaxValue(2000.0); + valueHigh.setMinValue(0.0); + valueHigh.setShowButtons(false); + + jLabel15.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel15.setText("Width:"); + + valueWidth.setDecimals(2); + valueWidth.setEnabled(false); + valueWidth.setMaxValue(2000.0); + valueWidth.setMinValue(0.0); + valueWidth.setShowButtons(false); + + javax.swing.GroupLayout jPanel4Layout = new javax.swing.GroupLayout(jPanel4); + jPanel4.setLayout(jPanel4Layout); + jPanel4Layout.setHorizontalGroup( + jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel4Layout.createSequentialGroup() + .addContainerGap() + .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jLabel15) + .addComponent(jLabel14) + .addComponent(jLabel13) + .addComponent(jLabel12) + .addComponent(jLabel11)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(valueWidth, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(valueHigh, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(valueCenter, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(comboPass, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(valueLow, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) + ); + + jPanel4Layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {comboPass, valueCenter, valueHigh, valueLow, valueWidth}); + + jPanel4Layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {jLabel11, jLabel12, jLabel13, jLabel14, jLabel15}); + + jPanel4Layout.setVerticalGroup( + jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel4Layout.createSequentialGroup() + .addContainerGap() + .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) + .addComponent(jLabel11) + .addComponent(comboPass, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) + .addComponent(jLabel12) + .addComponent(valueLow, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) + .addComponent(jLabel13) + .addComponent(valueCenter, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) + .addComponent(jLabel14) + .addComponent(valueHigh, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) + .addComponent(jLabel15) + .addComponent(valueWidth, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addContainerGap(17, Short.MAX_VALUE)) + ); + + jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Step")); + + jLabel8.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel8.setText("Time:"); + + valueTime.setDecimals(2); + valueTime.setMaxValue(1000.0); + valueTime.setMinValue(0.0); + valueTime.setShowButtons(false); + + jLabel9.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel9.setText("Size:"); + + valueSize.setDecimals(2); + valueSize.setMaxValue(1000.0); + valueSize.setMinValue(0.0); + valueSize.setShowButtons(false); + + jLabel10.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel10.setText("Slices:"); + + valueSlices.setDecimals(0); + valueSlices.setMaxValue(1000.0); + valueSlices.setMinValue(0.0); + valueSlices.setShowButtons(false); + + jLabel17.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING); + jLabel17.setText("Iter:"); + + valueIterations.setDecimals(0); + valueIterations.setMaxValue(1000.0); + valueIterations.setMinValue(0.0); + valueIterations.setShowButtons(false); + + javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2); + jPanel2.setLayout(jPanel2Layout); + jPanel2Layout.setHorizontalGroup( + jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel2Layout.createSequentialGroup() + .addContainerGap() + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel2Layout.createSequentialGroup() + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jLabel9) + .addComponent(jLabel8)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(valueSize, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(valueTime, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addGap(0, 0, Short.MAX_VALUE)) + .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel2Layout.createSequentialGroup() + .addGap(0, 0, Short.MAX_VALUE) + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel2Layout.createSequentialGroup() + .addComponent(jLabel10) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addComponent(valueSlices, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel2Layout.createSequentialGroup() + .addComponent(jLabel17) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addComponent(valueIterations, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))))) + .addContainerGap()) + ); + + jPanel2Layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {jLabel10, jLabel17, jLabel8, jLabel9}); + + jPanel2Layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {valueIterations, valueSize, valueSlices, valueTime}); + + jPanel2Layout.setVerticalGroup( + jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel2Layout.createSequentialGroup() + .addContainerGap() + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jLabel10) + .addComponent(valueSlices, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jLabel8) + .addComponent(valueTime, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jLabel9) + .addComponent(valueSize, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jLabel17) + .addComponent(valueIterations, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) + .addContainerGap()) + ); + + buttonZeroSupplies.setText("Zero Supplies"); + buttonZeroSupplies.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(java.awt.event.ActionEvent evt) { + buttonZeroSuppliesActionPerformed(evt); + } + }); + + javax.swing.GroupLayout jPanel6Layout = new javax.swing.GroupLayout(jPanel6); + jPanel6.setLayout(jPanel6Layout); + jPanel6Layout.setHorizontalGroup( + jPanel6Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel6Layout.createSequentialGroup() + .addGap(0, 0, 0) + .addComponent(jPanel4, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addGroup(jPanel6Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false) + .addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + .addGroup(jPanel6Layout.createSequentialGroup() + .addComponent(buttonZeroSupplies, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + .addContainerGap()))) + ); + jPanel6Layout.setVerticalGroup( + jPanel6Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(jPanel6Layout.createSequentialGroup() + .addGap(0, 0, 0) + .addGroup(jPanel6Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false) + .addComponent(jPanel4, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addGroup(jPanel6Layout.createSequentialGroup() + .addComponent(jPanel2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addComponent(buttonZeroSupplies))) + .addGap(0, 0, 0)) + ); + + jPanel6Layout.linkSize(javax.swing.SwingConstants.VERTICAL, new java.awt.Component[] {jPanel1, jPanel4}); + + javax.swing.GroupLayout scientaPanelLayout = new javax.swing.GroupLayout(scientaPanel); + scientaPanel.setLayout(scientaPanelLayout); + scientaPanelLayout.setHorizontalGroup( + scientaPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(scientaPanelLayout.createSequentialGroup() + .addGroup(scientaPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addComponent(jPanel5, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + .addComponent(plotSpectrum, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + .addComponent(jPanel6, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) + .addGap(0, 0, 0)) + ); + scientaPanelLayout.setVerticalGroup( + scientaPanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(scientaPanelLayout.createSequentialGroup() + .addComponent(jPanel6, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addGap(0, 0, 0) + .addComponent(jPanel5, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addGap(0, 0, 0) + .addComponent(plotSpectrum, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + .addGap(0, 0, 0)) + ); + + javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this); + this.setLayout(layout); + layout.setHorizontalGroup( + layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(layout.createSequentialGroup() + .addComponent(cameraPanel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) + .addComponent(scientaPanel, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) + ); + layout.setVerticalGroup( + layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) + .addGroup(layout.createSequentialGroup() + .addComponent(cameraPanel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) + .addGap(0, 0, Short.MAX_VALUE)) + .addComponent(scientaPanel, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) + ); + }// //GEN-END:initComponents + + private void comboLensActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboLensActionPerformed + try { + if (!isBackgroundUpdate()) { + Scienta.LensMode mode = (Scienta.LensMode) comboLens.getSelectedItem(); + if (mode != null) { + getDevice().setLensMode(mode); + } + } + } catch (Exception ex) { + showException(ex); + } + + }//GEN-LAST:event_comboLensActionPerformed + + private void comboAcquisitionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboAcquisitionActionPerformed + try { + if (!isBackgroundUpdate()) { + Scienta.AcquisitionMode mode = (Scienta.AcquisitionMode) comboAcquisition.getSelectedItem(); + if (mode != null) { + getDevice().setAcquisitionMode(mode); + } + } + } catch (Exception ex) { + showException(ex); + } + }//GEN-LAST:event_comboAcquisitionActionPerformed + + private void comboEnergyActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboEnergyActionPerformed + try { + if (!isBackgroundUpdate()) { + Scienta.EnergyMode mode = (Scienta.EnergyMode) comboEnergy.getSelectedItem(); + if (mode != null) { + getDevice().setEnergyMode(mode); + } + } + } catch (Exception ex) { + showException(ex); + } + }//GEN-LAST:event_comboEnergyActionPerformed + + private void comboDetectorActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboDetectorActionPerformed + try { + if (!isBackgroundUpdate()) { + Scienta.DetectorMode mode = (Scienta.DetectorMode) comboDetector.getSelectedItem(); + if (mode != null) { + getDevice().setDetectorMode(mode); + } + } + } catch (Exception ex) { + showException(ex); + } + }//GEN-LAST:event_comboDetectorActionPerformed + + private void comboElementActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboElementActionPerformed + try { + if (!isBackgroundUpdate()) { + Scienta.ElementSet mode = (Scienta.ElementSet) comboElement.getSelectedItem(); + if (mode != null) { + getDevice().setElementSet(mode); + } + } + } catch (Exception ex) { + showException(ex); + } + }//GEN-LAST:event_comboElementActionPerformed + + private void comboPassActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboPassActionPerformed + try { + if (!isBackgroundUpdate()) { + int val = (int) comboPass.getSelectedItem(); + getDevice().setPassEnergy(val); + } + } catch (Exception ex) { + showException(ex); + } + }//GEN-LAST:event_comboPassActionPerformed + + private void buttonZeroSuppliesActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZeroSuppliesActionPerformed + try { + getDevice().zeroSupplies(); + } catch (Exception ex) { + showException(ex); + } + }//GEN-LAST:event_buttonZeroSuppliesActionPerformed + + // Variables declaration - do not modify//GEN-BEGIN:variables + private javax.swing.JButton buttonZeroSupplies; + private ch.psi.pshell.swing.CameraPanel cameraPanel; + private javax.swing.JComboBox comboAcquisition; + private javax.swing.JComboBox comboDetector; + private javax.swing.JComboBox comboElement; + private javax.swing.JComboBox comboEnergy; + private javax.swing.JComboBox comboLens; + private javax.swing.JComboBox comboPass; + private javax.swing.JLabel jLabel1; + private javax.swing.JLabel jLabel10; + private javax.swing.JLabel jLabel11; + private javax.swing.JLabel jLabel12; + private javax.swing.JLabel jLabel13; + private javax.swing.JLabel jLabel14; + private javax.swing.JLabel jLabel15; + private javax.swing.JLabel jLabel16; + private javax.swing.JLabel jLabel17; + private javax.swing.JLabel jLabel2; + private javax.swing.JLabel jLabel3; + private javax.swing.JLabel jLabel4; + private javax.swing.JLabel jLabel5; + private javax.swing.JLabel jLabel6; + private javax.swing.JLabel jLabel8; + private javax.swing.JLabel jLabel9; + private javax.swing.JPanel jPanel1; + private javax.swing.JPanel jPanel2; + private javax.swing.JPanel jPanel4; + private javax.swing.JPanel jPanel5; + private javax.swing.JPanel jPanel6; + private ch.psi.pshell.plot.LinePlotJFree plot; + private javax.swing.JPanel plotSpectrum; + private javax.swing.JProgressBar progress; + private javax.swing.JPanel scientaPanel; + private ch.psi.pshell.swing.ValueSelection valueCenter; + private ch.psi.pshell.swing.ValueSelection valueCurrent; + private ch.psi.pshell.swing.ValueSelection valueHigh; + private ch.psi.pshell.swing.ValueSelection valueIterations; + private ch.psi.pshell.swing.ValueSelection valueLow; + private ch.psi.pshell.swing.ValueSelection valueSize; + private ch.psi.pshell.swing.ValueSelection valueSlices; + private ch.psi.pshell.swing.ValueSelection valueTime; + private ch.psi.pshell.swing.ValueSelection valueTotal; + private ch.psi.pshell.swing.ValueSelection valueWidth; + // End of variables declaration//GEN-END:variables +}