/*
 * Copyright (c) 2014 Paul Scherrer Institute. All rights reserved.
 */

import ch.psi.pshell.core.Context;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import javax.swing.DefaultComboBoxModel;
import ch.psi.pshell.ui.Panel;
import ch.psi.pshell.imaging.ImageListener;
import ch.psi.utils.State;
import ch.psi.utils.IO;
import ch.psi.utils.swing.SwingUtils;
import ch.psi.utils.swing.TextEditor;
import ch.psi.pshell.epics.PsiCamera;
import ch.psi.pshell.epics.Camtool;
import ch.psi.pshell.core.JsonSerializer;
import ch.psi.pshell.device.Device;
import ch.psi.pshell.epics.ArraySource;
import ch.psi.pshell.epics.ChannelDouble;
import ch.psi.pshell.epics.ChannelDoubleArray;
import ch.psi.pshell.epics.ChannelInteger;
import ch.psi.pshell.epics.ChannelIntegerArray;
import ch.psi.pshell.ui.App;
import ch.psi.pshell.imaging.Data;
import ch.psi.pshell.imaging.Overlay;
import ch.psi.pshell.imaging.Overlays;
import ch.psi.pshell.imaging.Overlays.Text;
import ch.psi.pshell.imaging.Pen;
import ch.psi.pshell.imaging.Renderer.Profile;
import ch.psi.pshell.imaging.Source;
import ch.psi.pshell.imaging.Utils;
import ch.psi.pshell.scripting.InterpreterResult;
import ch.psi.pshell.scripting.ScriptManager;
import ch.psi.utils.Arr;
import ch.psi.utils.ArrayProperties;
import ch.psi.utils.Convert;
import ch.psi.utils.Str;
import ch.psi.utils.swing.Editor.EditorDialog;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Point;
import java.awt.image.BufferedImage;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.math3.analysis.function.Gaussian;
import org.apache.commons.math3.fitting.GaussianCurveFitter;
import org.apache.commons.math3.fitting.WeightedObservedPoint;
import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
/**
 *
 */
public class Cameras extends Panel {

    public Cameras() {
        initComponents();
        renderer.setPersistenceFile(Paths.get(getContext().getSetup().getContextPath(), "Renderer_Cameras.bin"));
        setPersistedComponents(new Component[]{checkCamtool});
        comboCameras.setEnabled(false);
        if (App.hasArgument("poll")) {
            try{
                polling = Integer.valueOf(App.getArgumentValue("poll"));
            } catch (Exception ex){
                ex.printStackTrace();
            }
        } 
        if (App.hasArgument("zoom")) {
            try{
                renderer.setDefaultZoom(Double.valueOf(App.getArgumentValue("zoom")));
                renderer.resetZoom();
            } catch (Exception ex){
                ex.printStackTrace();
            }
        } 
    }        
    
    @Override
    public void onStart() {
        super.onStart();
        if (App.hasArgument("ct")) {
            checkCamtool.setSelected(!App.getArgumentValue("ct").equals("0") && !App.getArgumentValue("ct").equalsIgnoreCase("false"));            
        }
    }

    final String configFolder = "/afs/psi.ch/intranet/SF/Applications/config/camtool";
    File[] cameraConfigFiles = new File[0];
    ArraySource camera;
    String cameraName;
    String cameraConfigJson;
    CameraConfig config;
    int polling = 1000;
    Overlay marker = null;

    //Overridable callbacks
    @Override
    public void onInitialize(int runCount) {
        comboCameras.setEnabled(false);
        if (App.hasArgument("s")){
            renderer.setDevice((Source)getDevice("image"));
            renderer.setAutoScroll(true);             
            ((Source)getDevice("image")).addListener(new ImageListener() {
                @Override
                public void onImage(Object o, BufferedImage bi, Data data) {                 
                    if (bi == null) {
                        fitOv = null;
                    } else {
                        Overlay[] profile = renderer.getProfileOverlays();                        
                        profile = ((profile != null) && (profile.length==4)) ? getFitOverlays(data) : null; 
                        renderer.updateOverlays(profile, fitOv);
                        fitOv = profile;
                    }
                }
                @Override
                public void onError(Object o, Exception excptn) {
                }
            }       
            );
            
        } else {
            cameraConfigFiles = IO.listFiles(configFolder, new String[]{"json"});
            Arrays.sort(cameraConfigFiles, (a, b) -> a.compareTo(b));
            DefaultComboBoxModel model = new DefaultComboBoxModel();
            for (File file : cameraConfigFiles) {
                String prefix = IO.getPrefix(file);
                if (!prefix.startsWith("#")) {
                    model.addElement(prefix);
                }
            }
            comboCameras.setModel(model);
            comboCameras.setEnabled(true);
            comboCameras.setSelectedItem(-1);
            if (model.getSize() > 0) {
                try {
                    //setCamera((String)comboCameras.getSelectedItem());
                    if (App.hasArgument("cam")) {
                        comboCameras.setSelectedItem(App.getArgumentValue("cam"));
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }            
        }
        startTimer(1000);
    }

    @Override
    public void onStateChange(State state, State former) {

    }

    @Override
    public void onExecutedFile(String fileName, Object result) {
    }

    //Callback to perform update - in event thread
    @Override
    protected void doUpdate() {
    }

    public static class CameraConfig {

        public HashMap kwargs;
        public ArrayList args;
        public ArrayList links;
        public String type;
        public HashMap<String, Object> state;
        public CameraConfig image_source;
        public HashMap<String, CameraConfig> subcomponents;

        public ArrayList<Integer> getCalibration() {
            return (ArrayList<Integer>) state.get("calibration");
        }
 
        public double getCalOffsetX(){
            ArrayList<Integer> calibration = getCalibration();
            double ret = - (calibration.get(0) + calibration.get(2))/2;
            return ret;        
        }

        public double getCalOffsetY(){
            ArrayList<Integer> calibration = getCalibration();
            double ret = - (calibration.get(1) + calibration.get(3))/2;
            return ret;
        }

        public double getScaleX(){
            ArrayList<Integer> calibration = getCalibration();
            double width = Math.abs( calibration.get(2) - calibration.get(0));
            return getCalibrationWidth()/width;
            //return getCalibrationWidth()/1000;
        }

        public double getScaleY(){
            ArrayList<Integer> calibration = getCalibration();
            double height = Math.abs( calibration.get(3) - calibration.get(1));
            return getCalibrationHeight()/height;
        }
        

        public Double getCalibrationHeight() {
            return (Double) state.get("calibration_height");
        }

        public Double getCalibrationWidth() {
            return (Double) state.get("calibration_width");
        }

        public Double getCalibrationHorizontalAngle() {
            return (Double) state.get("calibration_horizontal_angle");
        }

        public Double getCalibrationVerticalAngle() {
            return (Double) state.get("calibration_vertical_angle");
        }

        public Boolean getMirrorX() {
            return (Boolean) state.get("mirror_x");
        }

        public Boolean getMirrorY() {
            return (Boolean) state.get("mirror_y");
        }

        public Integer getRotate() {
            return (Integer) state.get("rotate");
        }

        public ArrayList<Integer> getOrigin() {
            return (ArrayList<Integer>) state.get("origin");
        }

        public ArrayList<Integer> getRoi() {
            return (ArrayList<Integer>) state.get("roi");
        }

        public Boolean getRoiEnable() {
            if ((state.get("roi_enable") == null) || (state.get("roi") == null)) {
                return false;
            }
            return (Boolean) state.get("roi_enable");
        }

        public ArrayList<Double> getUnitSize() {
            return (ArrayList<Double>) state.get("unit_size");
        }

        public Integer getRun() {
            return (Integer) state.get("run");
        }
    }
    
    Overlay[] fitOv;

    void setCamera(String cameraName) throws IOException, InterruptedException {
        System.out.println("Setting camera: " + cameraName);
        if (camera != null) {
            camera.close();
            camera = null;
            renderer.setDevice(null);
            renderer.setShowReticle(false);
            renderer.removeOverlays(fitOv);
            renderer.clear();
            renderer.resetZoom();
        }
        try {
            Path configFile = Paths.get(configFolder, cameraName + ".json");
            cameraConfigJson = new String(Files.readAllBytes(configFile));
            this.cameraName = cameraName;
            //SwingUtils.showMessage(null, "", json);
            try {
                if (checkCamtool.isSelected()) {
                    camera = new Camtool("CurrentCamera", cameraName, false);                    
                    camera.getConfig().flipHorizontally = false;
                    camera.getConfig().flipVertically = false;
                    camera.getConfig().rotation = 0.0;
                    camera.getConfig().roiX = 0;
                    camera.getConfig().roiY = 0;
                    camera.getConfig().roiWidth = -1;
                    camera.getConfig().roiHeight = -1;
                } else {
                    camera = new PsiCamera("CurrentCamera", cameraName);
                    config = (CameraConfig) JsonSerializer.decode(cameraConfigJson, CameraConfig.class);
                    camera.getConfig().flipHorizontally = config.getMirrorX();
                    camera.getConfig().flipVertically = config.getMirrorY();
                    camera.getConfig().rotation = config.getRotate();
                    camera.getConfig().rotationCrop = true;
                    camera.getConfig().roiX = config.getRoiEnable() ? config.getRoi().get(0) : 0;
                    camera.getConfig().roiY = config.getRoiEnable() ? config.getRoi().get(1) : 0;
                    camera.getConfig().roiWidth = config.getRoiEnable() ? config.getRoi().get(2) : -1;
                    camera.getConfig().roiHeight = config.getRoiEnable() ? config.getRoi().get(3) : -1;
                    try{
                        camera.getConfig().spatialCalOffsetX = config.getCalOffsetX();
                        camera.getConfig().spatialCalOffsetY = config.getCalOffsetY();
                        camera.getConfig().spatialCalScaleX = config.getScaleX();
                        camera.getConfig().spatialCalScaleY = config.getScaleY();
                    } catch (Exception ex){
                        camera.getConfig().spatialCalOffsetX = Double.NaN;
                        camera.getConfig().spatialCalOffsetY = Double.NaN;
                        camera.getConfig().spatialCalScaleX =  Double.NaN;
                        camera.getConfig().spatialCalScaleY = Double.NaN;                        
                    }
                }
            } catch (Exception ex) {
                config = null;
                showException(ex);
            }            
            camera.initialize();
            if (camera instanceof Camtool){
                    try{
                        camera.getConfig().spatialCalOffsetX = ((Camtool)camera).calOffX.read();
                        camera.getConfig().spatialCalOffsetY = ((Camtool)camera).calOffY.read();
                        camera.getConfig().spatialCalScaleX = ((Camtool)camera).calScaleX.read();
                        camera.getConfig().spatialCalScaleY = ((Camtool)camera).calScaleY.read();
                    } catch (Exception ex){
                        ex.printStackTrace();
                        camera.getConfig().spatialCalOffsetX = 0.0;
                        camera.getConfig().spatialCalOffsetY = 0.0;
                        camera.getConfig().spatialCalScaleX = 1.0;
                        camera.getConfig().spatialCalScaleY = 1.0;
                    }
                    /*
                    double[] origin = ((Camtool)camera).origin.read();
                    if (origin.length>=2){
                        camera.getConfig().spatialCalOffsetX = origin[0];
                        camera.getConfig().spatialCalOffsetY = origin[1];                
                    }
                            */
            }
            buttonReticle.setEnabled(camera.getConfig().isCalibrated());
            buttonGrabBackground.setEnabled(camera instanceof Camtool);
            camera.getConfig().save();
            
            if (polling<=0){
                camera.setMonitored(true);
            } else {
                camera.setPolling(-polling);
            }                        
            renderer.setDevice(camera);            
            renderer.setAutoScroll(true);
            renderer.setMarker(marker);

            camera.addListener(new ImageListener() {
                @Override
                public void onImage(Object o, BufferedImage bi, Data data) {
                    if (bi == null) {
                        renderer.removeOverlays(fitOv);
                        fitOv = null;
                    } else {
                        //System.out.println(bi.getWidth() + " - " + bi.getHeight());
                        if (!renderer.isPaused() && buttonFit.isSelected()){
                            Overlay[] profile = renderer.getProfileOverlays();                        
                            profile = ((profile != null) && (profile.length==4)) ? getFitOverlays(data) : null; 
                            renderer.updateOverlays(profile, fitOv);
                            fitOv = profile;
                        }
                    }
                }

                @Override
                public void onError(Object o, Exception excptn) {
                }
            });
        } catch (Exception ex) {
            if (renderer.getDevice()==null){
                renderer.setZoom(1.0);
                renderer.addOverlay(new Text(renderer.getPenErrorText(), ex.toString(), new Font("Verdana", Font.PLAIN, 12), new Point(20, 20)));
            }            
        } finally {            
           checkReticle();           
           onTimer();           
        }
    }
    
    void checkReticle(){
        if ((renderer.getDevice()!=null) && (camera!=null) && (camera.getConfig().isCalibrated()) && buttonReticle.isSelected()){
            renderer.setCalibration(camera.getCalibration());                    
            renderer.configureReticle(new Dimension(800,800), 200);
            renderer.setShowReticle(true);                                         
        } else {
            renderer.setShowReticle(false);                                         
        }
        renderer.refresh();
    }   

    @Override
    protected void onTimer() {
        textState.setText((camera == null) ? "" : camera.getState().toString());
        buttonConfig.setEnabled(camera != null);
        if (App.hasArgument("s")){
            try {
                ((Source)getDevice("image")).initialize();
            } catch (IOException ex) {
                Logger.getLogger(Cameras.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InterruptedException ex) {
                Logger.getLogger(Cameras.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    
    Pen fitPen = new Pen(new Color(192, 105, 0), 1);
    Pen crossPen = new Pen(new Color(192, 105, 0), 1);

    Overlay[] getFitOverlays(Data data) {
        Overlays.Polyline hpoly = null;
        Overlays.Polyline vpoly = null;
        Double xMean = null;
        Double xSigma = null;
        Double yMean = null;
        Double ySigma = null;
        if (data != null) {
            //img = Utils.grayscale(img);
            int profileSize = Math.min(data.getWidth(), data.getHeight())/4;

            try {
                double[] sum = (double[]) Convert.toDouble(data.integrateVertically(true));
                int[] x = Arr.indexesInt(sum.length);
                DescriptiveStatistics stats = new DescriptiveStatistics(sum);
                double min = stats.getMin();
                for (int i = 0; i < sum.length; i++) {
                    sum[i] = sum[i] - min;
                }

                double[] gaussian = fitGaussian(sum, x);
                if (gaussian != null) {
                    if ((gaussian[2] < sum.length * 0.45) && (gaussian[0] > min * 0.03)) {
                        double maxPlot = gaussian[0];
                        xMean = gaussian[1];
                        xSigma = gaussian[2];
                        gaussian[0] += min;
                        double[] fit = getFitFunction(gaussian, x);
                        int[] y = new int[x.length];
                        for (int i = 0; i < x.length; i++) {
                            y[i] = (int) (data.getHeight() - 1 - ((fit[i] / maxPlot) * profileSize));
                        }
                        vpoly = new Overlays.Polyline(fitPen, x, y);
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }

            try {
                double[] sum = (double[]) Convert.toDouble(data.integrateHorizontally(true));
                int[] x = Arr.indexesInt(sum.length);
                DescriptiveStatistics stats = new DescriptiveStatistics(sum);
                double min = stats.getMin();
                for (int i = 0; i < sum.length; i++) {
                    sum[i] = sum[i] - min;
                }

                double[] gaussian = fitGaussian(sum, x);
                if (gaussian != null) {
                    //Only aknowledge beam fully inside the image and peak over 3% of min
                    if ((gaussian[2] < sum.length * 0.45) && (gaussian[0] > min * 0.03)) {
                        double maxPlot = gaussian[0];
                        yMean = gaussian[1];
                        ySigma = gaussian[2];
                        gaussian[0] += min;
                        double[] fit = getFitFunction(gaussian, x);

                        int[] y = new int[x.length];
                        for (int i = 0; i < x.length; i++) {
                            y[i] = (int) ((fit[i] / maxPlot) * profileSize);
                        }
                        hpoly = new Overlays.Polyline(fitPen, y, x);
                    }
                }

            } catch (Exception ex) {
                ex.printStackTrace();
            }

            Overlays.Crosshairs cross = null;
            Overlays.Text text = null;
            if ((xMean != null) && (yMean != null)) {
                cross = new Overlays.Crosshairs(crossPen,
                        new Point(xMean.intValue(), yMean.intValue()),
                        new Dimension(2 * xSigma.intValue(), 2 * ySigma.intValue()));
                
                text = new  Overlays.Text(fitPen, 
                             String.format("x = %f \n y = %f" , data.getX((int) Math.round(xMean)), data.getY((int) Math.round(yMean))), 
                        new Font(Font.MONOSPACED, 0, 14), new Point(20,20));
            }
            
            return new Overlay[]{hpoly, vpoly, cross, text};
        }
        return null;
    }

    double[] fitGaussianScript(int[] y, int[] x) {
        ScriptManager sm = Context.getInstance().getScriptManager();
        ArrayProperties pY = ArrayProperties.get(y);
        sm.setVar("y", y);
        sm.setVar("x", x);
        InterpreterResult r = sm.eval("r = fit_gaussians(y, x, [" + pY.maxIndex + ",])");
        if (r.exception != null) {
            r.exception.printStackTrace();
        } else {
            List ret = (List) sm.getVar("r");
            if ((ret != null) && (ret.size() == 1) && (ret.get(0) instanceof List) && (((List) (ret.get(0))).size() == 3)) {
                double norm = (Double) ((List) ret.get(0)).get(0);
                double mean = (Double) ((List) ret.get(0)).get(1);
                double sigma = (Double) ((List) ret.get(0)).get(2);
                return new double[]{norm, mean, sigma};
            }
        }
        return null;
    }

    double[] fitGaussian(double[] y, int[] x) {
        try {
            ArrayProperties pY = ArrayProperties.get(y);
            GaussianCurveFitter fitter = GaussianCurveFitter.create().withStartPoint(new double[]{(pY.max - pY.min) / 2, x[pY.maxIndex], 1.0}).withMaxIterations(1000);
            ArrayList<WeightedObservedPoint> values = new ArrayList<>();
            for (int i = 0; i < y.length; i++) {
                values.add(new WeightedObservedPoint(1.0, x[i], y[i]));
            }
            return fitter.fit(values);
        } catch (Exception ex) {
            return null;
        }

    }

    double[] getFitFunction(double[] pars, int[] x) {
        double[] fit = new double[x.length];
        Gaussian g = new Gaussian(pars[0], pars[1], pars[2]);
        for (int i = 0; i < x.length; i++) {
            fit[i] = g.value(x[i]);
        }
        return fit;
    }
        
    
    ////////
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        renderer = new ch.psi.pshell.imaging.Renderer();
        jLabel1 = new javax.swing.JLabel();
        comboCameras = new javax.swing.JComboBox();
        jLabel2 = new javax.swing.JLabel();
        textState = new javax.swing.JTextField();
        buttonConfig = new javax.swing.JButton();
        buttonSetup = new javax.swing.JButton();
        checkCamtool = new javax.swing.JCheckBox();
        buttonFit = new javax.swing.JToggleButton();
        buttonPause = new javax.swing.JToggleButton();
        buttonMarker = new javax.swing.JToggleButton();
        buttonSave = new javax.swing.JToggleButton();
        buttonReticle = new javax.swing.JToggleButton();
        buttonGrabBackground = new javax.swing.JButton();

        jLabel1.setText("Camera:");

        comboCameras.setMaximumRowCount(30);
        comboCameras.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                comboCamerasActionPerformed(evt);
            }
        });

        jLabel2.setText("State:");

        textState.setEditable(false);
        textState.setHorizontalAlignment(javax.swing.JTextField.CENTER);
        textState.setDisabledTextColor(new java.awt.Color(0, 0, 0));
        textState.setEnabled(false);

        buttonConfig.setText("Config");
        buttonConfig.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonConfigActionPerformed(evt);
            }
        });

        buttonSetup.setText("Setup");
        buttonSetup.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonSetupActionPerformed(evt);
            }
        });

        checkCamtool.setSelected(true);
        checkCamtool.setText("Camtool");

        buttonFit.setSelected(true);
        buttonFit.setText("Fit");
        buttonFit.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonFitActionPerformed(evt);
            }
        });

        buttonPause.setText("Pause");
        buttonPause.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonPauseActionPerformed(evt);
            }
        });

        buttonMarker.setText("Marker");
        buttonMarker.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonMarkerActionPerformed(evt);
            }
        });

        buttonSave.setText("Save Snapshot");
        buttonSave.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonSaveActionPerformed(evt);
            }
        });

        buttonReticle.setSelected(true);
        buttonReticle.setText("Reticle");
        buttonReticle.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonReticleActionPerformed(evt);
            }
        });

        buttonGrabBackground.setText("Grab Background");
        buttonGrabBackground.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                buttonGrabBackgroundActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(renderer, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 650, Short.MAX_VALUE)
                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                        .addComponent(checkCamtool)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(jLabel1)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(comboCameras, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(buttonConfig)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(buttonSetup)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(jLabel2)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(textState, javax.swing.GroupLayout.PREFERRED_SIZE, 120, javax.swing.GroupLayout.PREFERRED_SIZE))
                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                        .addComponent(buttonPause)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(buttonMarker)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(buttonFit)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(buttonReticle)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                        .addComponent(buttonGrabBackground)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(buttonSave)))
                .addContainerGap())
        );

        layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {buttonConfig, buttonSetup});

        layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {buttonFit, buttonMarker, buttonPause, buttonReticle});

        layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {buttonGrabBackground, buttonSave});

        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel1)
                    .addComponent(comboCameras, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jLabel2)
                    .addComponent(textState, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(buttonConfig)
                    .addComponent(buttonSetup)
                    .addComponent(checkCamtool))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(renderer, javax.swing.GroupLayout.DEFAULT_SIZE, 307, Short.MAX_VALUE)
                .addGap(12, 12, 12)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(buttonPause)
                    .addComponent(buttonFit)
                    .addComponent(buttonMarker)
                    .addComponent(buttonSave)
                    .addComponent(buttonReticle)
                    .addComponent(buttonGrabBackground))
                .addContainerGap())
        );

        layout.linkSize(javax.swing.SwingConstants.VERTICAL, new java.awt.Component[] {comboCameras, textState});

    }// </editor-fold>//GEN-END:initComponents

    private void comboCamerasActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboCamerasActionPerformed
        try {
            comboCameras.setEnabled(false);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        setCamera((String) comboCameras.getSelectedItem());
                    } catch(Exception ex){
                        ex.printStackTrace();
                    } finally{
                        comboCameras.setEnabled(true);
                    }
                }
            }).start();            
        } catch (Exception ex) {
            showException(ex);
        }
    }//GEN-LAST:event_comboCamerasActionPerformed

    private void buttonConfigActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonConfigActionPerformed
        try {
            if (camera != null) {
                TextEditor editor = new TextEditor();
                editor.setText(cameraConfigJson);
                editor.setReadOnly(true);
                editor.setTitle(cameraName);
                EditorDialog dlg = editor.getDialog(getTopLevel(), false);
                dlg.setSize(480, 640);
                dlg.setVisible(true);
                SwingUtils.centerComponent(this, dlg);
            }
        } catch (Exception ex) {
            showException(ex);
        }
    }//GEN-LAST:event_buttonConfigActionPerformed

    private void buttonSetupActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonSetupActionPerformed
        try {
            if (camera != null) {
                this.showDeviceConfigDialog(camera, false);
            }
        } catch (Exception ex) {
            showException(ex);
        }
    }//GEN-LAST:event_buttonSetupActionPerformed

    private void buttonPauseActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonPauseActionPerformed
        try {
            if (camera != null) {
                if (buttonPause.isSelected()){
                    renderer.pause();
                } else {
                    renderer.resume();
                }
            }
        } catch (Exception ex) {
            showException(ex);
        }
    }//GEN-LAST:event_buttonPauseActionPerformed

    private void buttonMarkerActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonMarkerActionPerformed
        try {
            if (camera != null) {
                if (buttonMarker.isSelected()){
                        Dimension d = renderer.getImageSize();
                        Point p = (d == null) ? new Point(renderer.getWidth() / 2, renderer.getHeight() / 2) : new Point(d.width / 2, d.height / 2);
                        Overlay ov = null;
                        marker = new Overlays.Crosshairs(renderer.getPenMarker(), p, new Dimension(100, 100));
                        marker.setMovable(true);                        
                } else {
                    marker = null;
                }
                renderer.setMarker(marker);
            }
        } catch (Exception ex) {
            showException(ex);
        }        
    }//GEN-LAST:event_buttonMarkerActionPerformed

    private void buttonFitActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonFitActionPerformed
        try {
            renderer.setProfile(buttonFit.isSelected() ? Profile.Both :Profile.None);
            if (!buttonFit.isSelected()){
                renderer.removeOverlays(fitOv);
                fitOv = null;                
            }
        } catch (Exception ex) {
            showException(ex);
        }                                  
    }//GEN-LAST:event_buttonFitActionPerformed

    private void buttonReticleActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonReticleActionPerformed
        try {
            checkReticle();            
        } catch (Exception ex) {
            showException(ex);
        }                          
    }//GEN-LAST:event_buttonReticleActionPerformed

    private void buttonSaveActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonSaveActionPerformed
        try {
            renderer.setSnapshotDialogVisible(buttonSave.isSelected());
        } catch (Exception ex) {
            showException(ex);
        } 
    }//GEN-LAST:event_buttonSaveActionPerformed

    private void buttonGrabBackgroundActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonGrabBackgroundActionPerformed
        try {
            if (camera instanceof Camtool){
                ((Camtool)camera).captureBackground(5);
            }            
        } catch (Exception ex) {
            showException(ex);
        }        
    }//GEN-LAST:event_buttonGrabBackgroundActionPerformed

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JButton buttonConfig;
    private javax.swing.JToggleButton buttonFit;
    private javax.swing.JButton buttonGrabBackground;
    private javax.swing.JToggleButton buttonMarker;
    private javax.swing.JToggleButton buttonPause;
    private javax.swing.JToggleButton buttonReticle;
    private javax.swing.JToggleButton buttonSave;
    private javax.swing.JButton buttonSetup;
    private javax.swing.JCheckBox checkCamtool;
    private javax.swing.JComboBox comboCameras;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private ch.psi.pshell.imaging.Renderer renderer;
    private javax.swing.JTextField textState;
    // End of variables declaration//GEN-END:variables
}