Ignore:
Timestamp:
2011-12-08T15:13:10+01:00 (13 years ago)
Author:
larry0ua
Message:

'PicLayer - 1. now all toolbar operations are done relatively to screen center. 2. If user tries to close layer without saving - confirmation is needed. 3. Other small fixes'

Location:
applications/editors/josm/plugins/piclayer/src/org/openstreetmap/josm/plugins/piclayer
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • applications/editors/josm/plugins/piclayer/src/org/openstreetmap/josm/plugins/piclayer/PicLayerPlugin.java

    r27168 r27191  
    3030
    3131import javax.swing.JMenu;
     32import javax.swing.JOptionPane;
     33import javax.swing.UIManager;
    3234
    3335import org.openstreetmap.josm.Main;
     
    3941import org.openstreetmap.josm.plugins.Plugin;
    4042import org.openstreetmap.josm.plugins.PluginInformation;
     43import org.openstreetmap.josm.plugins.piclayer.actions.SavePictureCalibrationAction;
    4144import org.openstreetmap.josm.plugins.piclayer.actions.newlayer.NewLayerFromClipboardAction;
    4245import org.openstreetmap.josm.plugins.piclayer.actions.newlayer.NewLayerFromFileAction;
     
    154157    @Override
    155158    public void layerRemoved(Layer arg0) {
     159        if (arg0 instanceof PicLayerAbstract && ((PicLayerAbstract) arg0).getTransformer().isModified()) {
     160            if (JOptionPane.showConfirmDialog(Main.parent, tr("Do you want to save current calibration of layer {0}?",
     161                    ((PicLayerAbstract)arg0).getPicLayerName()),
     162                    UIManager.getString("OptionPane.titleText"),
     163                    JOptionPane.YES_NO_OPTION) == 0)
     164                new SavePictureCalibrationAction((PicLayerAbstract) arg0).actionPerformed(null);
     165        }
    156166        boolean enable = Main.map.mapView.getAllLayers().size() != 0;
    157167        menu.setEnabled(enable);
  • applications/editors/josm/plugins/piclayer/src/org/openstreetmap/josm/plugins/piclayer/actions/LoadPictureCalibrationAction.java

    r27120 r27191  
    3737/**
    3838 * Action to load the calibration file.
    39  * 
     39 *
    4040 */
    4141@SuppressWarnings("serial")
     
    4444    // Owner layer of the action
    4545    PicLayerAbstract m_owner = null;
    46    
     46
    4747    // Persistent FileChooser instance to remember last directory
    4848    JFileChooser m_filechooser = null;
     
    6060     * Action handler
    6161     */
     62    @Override
    6263    public void actionPerformed(ActionEvent arg0) {
    6364        // Save dialog
    6465        JFileChooser fc = new JFileChooser();
    65         fc.setAcceptAllFileFilterUsed( false );
     66        fc.setAcceptAllFileFilterUsed( true );
    6667        fc.setFileFilter( new CalibrationFileFilter() );
    6768        fc.setSelectedFile( new File(m_owner.getPicLayerName() + CalibrationFileFilter.EXTENSION));
     
    6970
    7071        if ( result == JFileChooser.APPROVE_OPTION ) {
    71                    
    72             // Load 
     72
     73            // Load
    7374            try {
    7475                m_owner.loadCalibration(new FileInputStream(fc.getSelectedFile()));
     
    8081        }
    8182    }
    82    
     83
    8384}
  • applications/editors/josm/plugins/piclayer/src/org/openstreetmap/josm/plugins/piclayer/actions/SavePictureCalibrationAction.java

    r27144 r27191  
    6363        // Save dialog
    6464        final JFileChooser fc = new JFileChooser();
    65         fc.setAcceptAllFileFilterUsed( false );
     65        fc.setAcceptAllFileFilterUsed( true );
    6666        fc.setFileFilter( new CalibrationFileFilter() );
    6767        fc.setSelectedFile( new File(m_owner.getPicLayerName() + CalibrationFileFilter.EXTENSION));
  • applications/editors/josm/plugins/piclayer/src/org/openstreetmap/josm/plugins/piclayer/actions/newlayer/NewLayerFromFileAction.java

    r27149 r27191  
    107107        // Choose a file
    108108        JFileChooser fc = new JFileChooser(Main.pref.get(m_lastdirprefname));
    109         fc.setAcceptAllFileFilterUsed( false );
    110         //fc.setFileFilter( new ImageFileFilter() );
    111         fc.addChoosableFileFilter(new ImageFileFilter());
    112         fc.addChoosableFileFilter(new AllFilesFilter());
     109        fc.setAcceptAllFileFilterUsed( true );
     110        fc.setFileFilter( new ImageFileFilter() );
     111
    113112        fc.setMultiSelectionEnabled(true);
    114113        int result = fc.showOpenDialog( Main.parent );
  • applications/editors/josm/plugins/piclayer/src/org/openstreetmap/josm/plugins/piclayer/layer/PicLayerAbstract.java

    r27168 r27191  
    368368        props.put(POSITION_Y, Double.toString(imagePosition.getY()));
    369369        props.put(INITIAL_SCALE, Double.toString(initialImageScale));
     370
     371        transformer.resetModified();
    370372    }
    371373
     
    497499    public void movePictureBy(double x, double y) {
    498500        imagePosition = imagePosition.add(x, y);
    499     }
     501        transformer.setModified();
     502    }
     503
    500504
    501505    public void rotatePictureBy(double angle) {
    502         transformer.concatenateTransform(AffineTransform.getRotateInstance(angle));
     506        try {
     507            Point2D trans = transformPoint(new Point(Main.map.mapView.getWidth()/2, Main.map.mapView.getHeight()/2));
     508
     509            transformer.concatenateTransformPoint(AffineTransform.getRotateInstance(angle), trans);
     510        } catch (NoninvertibleTransformException e) {
     511            e.printStackTrace();
     512        }
    503513    }
    504514
    505515    public void scalePictureBy(double scalex, double scaley) {
    506         transformer.concatenateTransform(AffineTransform.getScaleInstance(scalex, scaley));
     516        try {
     517            Point2D trans = transformPoint(new Point(Main.map.mapView.getWidth()/2, Main.map.mapView.getHeight()/2));
     518
     519            transformer.concatenateTransformPoint(AffineTransform.getScaleInstance(scalex, scaley), trans);
     520        } catch (NoninvertibleTransformException e) {
     521            e.printStackTrace();
     522        }
    507523    }
    508524
    509525    public void shearPictureBy(double shx, double shy) {
    510         transformer.concatenateTransform(AffineTransform.getShearInstance(shx, shy));
     526        try {
     527            Point2D trans = transformPoint(new Point(Main.map.mapView.getWidth()/2, Main.map.mapView.getHeight()/2));
     528
     529            transformer.concatenateTransformPoint(AffineTransform.getShearInstance(shx, shy), trans);
     530        } catch (NoninvertibleTransformException e) {
     531            e.printStackTrace();
     532        }
    511533    }
    512534
  • applications/editors/josm/plugins/piclayer/src/org/openstreetmap/josm/plugins/piclayer/transform/PictureTransform.java

    r27120 r27191  
    99
    1010        private AffineTransform cachedTransform;
    11        
     11        private boolean modified = false;
     12
    1213        private List<Point2D> originPoints;
    1314        private List<Point2D> desiredPoints;
    14        
     15
    1516        public PictureTransform() {
    1617                cachedTransform = new AffineTransform();
     
    1819                desiredPoints = new ArrayList<Point2D>(3);
    1920        }
    20        
     21
    2122        public AffineTransform getTransform() {
    2223                return cachedTransform;
    2324        }
    24        
     25
    2526        public List<? extends Point2D> getOriginPoints() {
    2627                return originPoints;
    2728        }
    28        
     29
    2930        public List<? extends Point2D> getDesiredPoints() {
    3031                return desiredPoints;
    3132        }
    32        
     33
    3334        public void addDesiredPoint(Point2D picturePoint) {
    3435                if (desiredPoints.size() < 3)
     
    3637                trySolve();
    3738        }
    38        
     39
    3940        private AffineTransform solveEquation() throws NoSolutionException {
    4041                Matrix3D X = new Matrix3D(originPoints);
    4142                Matrix3D Y = new Matrix3D(desiredPoints);
    4243                Matrix3D result = Y.multiply(X.inverse());
    43                
     44
    4445                return result.toAffineTransform();
    4546        }
     
    5051                trySolve();
    5152        }
    52        
     53
    5354        public void resetCalibration() {
    5455                originPoints.clear();
    5556                desiredPoints.clear();
     57                modified = false;
    5658                cachedTransform = new AffineTransform();
    5759        }
     
    6163                        try {
    6264                                cachedTransform.concatenate(solveEquation());
     65                                modified = true;
    6366                                desiredPoints.clear();
    6467                        } catch (NoSolutionException e) {
     
    6871        }
    6972
    70         /** 
     73        /**
    7174         * updates pair of points (suppose that other pairs are (origin=>origin) points are the same),
    72          * solves equation, 
     75         * solves equation,
    7376         * applies transform matrix to the existing cachedTransform
    74          * 
     77         *
    7578         * @param originPoint - should be one of origin points, otherwise - no transform applied
    7679         * @param desiredPoint - new place for the point
     
    7982                if (originPoints.size() < 3) // not enough information for creating transform - 3 points needed
    8083                        return;
    81                
    82                 if (originPoint == null) 
     84
     85                if (originPoint == null)
    8386                        return;
    84                
     87
    8588                desiredPoints.clear();
    86                
     89
    8790                for (Point2D origin : originPoints) {
    8891                        if (origin.equals(originPoint))
     
    9598
    9699        public void replaceOriginPoint(Point2D originPoint, Point2D newOriginPoint) {
    97                 if (originPoint == null || newOriginPoint == null) 
     100                if (originPoint == null || newOriginPoint == null)
    98101                        return;
    99                
     102
    100103                int index = originPoints.indexOf(originPoint);
    101                 if (index < 0) 
     104                if (index < 0)
    102105                        return;
    103                
     106
    104107                originPoints.set(index, newOriginPoint);
    105108        }
    106        
    107         public void concatenateTransform(AffineTransform transform) {
    108                 cachedTransform.concatenate(transform);
     109
     110        public void concatenateTransformPoint(AffineTransform transform, Point2D trans) {
     111
     112        AffineTransform centered = AffineTransform.getTranslateInstance(trans.getX(), trans.getY());
     113        centered.concatenate(transform);
     114        centered.translate(-trans.getX(), -trans.getY());
     115        cachedTransform.concatenate(centered);
     116
     117
    109118                for (int i = 0; i < originPoints.size(); i++) {
    110119                        Point2D point = originPoints.get(i);
    111120                        transform.transform(point, point);
    112121                }
     122                modified = true;
    113123        }
     124
     125        public boolean isModified() {
     126            return modified;
     127        }
     128
     129    public void setModified() {
     130        modified = true;
     131
     132    }
     133
     134    public void resetModified() {
     135        modified = false;
     136    }
    114137}
Note: See TracChangeset for help on using the changeset viewer.