Changeset 30639 in osm for applications/editors/josm


Ignore:
Timestamp:
2014-09-15T02:11:10+02:00 (10 years ago)
Author:
donvip
Message:

[josm_videomapping] update to vlcj 3.0.1 / JNA 3.5.2 + fix various exceptions seen in testing

Location:
applications/editors/josm/plugins/videomapping
Files:
5 added
5 deleted
7 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/videomapping/.classpath

    r30416 r30639  
    44        <classpathentry kind="src" path="test"/>
    55        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
    6         <classpathentry exported="true" kind="lib" path="lib/vlcj-2.1.0.jar" sourcepath="lib/vlcj-2.1.0-sources.jar">
    7                 <attributes>
    8                         <attribute name="javadoc_location" value="jar:platform:/resource/VideoMapping/lib/vlcj-2.1.0-javadoc.jar!/"/>
    9                 </attributes>
    10         </classpathentry>
    116        <classpathentry combineaccessrules="false" kind="src" path="/JOSM"/>
    12         <classpathentry exported="true" kind="lib" path="lib/jna-3.4.0.jar"/>
    13         <classpathentry exported="true" kind="lib" path="lib/platform-3.4.0.jar"/>
    147        <classpathentry combineaccessrules="false" kind="src" path="/JOSM-log4j"/>
     8        <classpathentry kind="lib" path="lib/jna-3.5.2.jar"/>
     9        <classpathentry kind="lib" path="lib/platform-3.5.2.jar"/>
     10        <classpathentry kind="lib" path="lib/vlcj-3.0.1.jar"/>
    1511        <classpathentry kind="output" path="bin"/>
    1612</classpath>

  • applications/editors/josm/plugins/videomapping/build.xml

    r30530 r30639  
    1414    <import file="../build-common.xml"/>
    1515
    16     <property name="vlcj" value="${plugin.lib.dir}/vlcj-2.1.0.jar"/>
    17     <property name="jna" value="${plugin.lib.dir}/jna-3.4.0.jar"/>
    18     <property name="platform" value="${plugin.lib.dir}/platform-3.4.0.jar"/>
     16    <property name="vlcj" value="${plugin.lib.dir}/vlcj-3.0.1.jar"/>
     17    <property name="jna" value="${plugin.lib.dir}/jna-3.5.2.jar"/>
     18    <property name="platform" value="${plugin.lib.dir}/platform-3.5.2.jar"/>
    1919    <!-- classpath -->
    2020    <path id="classpath">

  • applications/editors/josm/plugins/videomapping/src/org/openstreetmap/josm/plugins/videomapping/VideoPlugin.java

    r30479 r30639  
    6565    private GPSVideoPlayer gpsVideoPlayer;
    6666
    67     public static String VLC_VERSION = "2.0.x";
     67    public static String VLC_VERSION = "2.1.x";
    6868
    6969    public VideoPlugin(PluginInformation info) {

  • applications/editors/josm/plugins/videomapping/src/org/openstreetmap/josm/plugins/videomapping/VideoPositionLayer.java

    r29531 r30639  
    11package org.openstreetmap.josm.plugins.videomapping;
    2 
    32
    43import static org.openstreetmap.josm.tools.I18n.tr;
    … …  
    3938//Basic rendering and GPS layer interaction
    4039public class VideoPositionLayer extends Layer implements MouseListener,MouseMotionListener {
    41         private List<WayPoint> gpsTrack;
    42         private ImageIcon layerIcon;
    43         private DateFormat gpsTimeFormat;
    44         private WayPoint iconPosition;
    45         private final int GPS_INTERVALL=1000;
    46         private GPSVideoPlayer gpsVideoPlayer;
    47         private boolean autoCenter;
    48 
    49         public VideoPositionLayer(GpxLayer gpsLayer) {
    50                 super("videolayer");
    51                 layerIcon = new ImageIcon("images/videomapping.png");
    52                 gpsTrack=importGPSLayer(gpsLayer.data);
    53                 gpsTimeFormat= new SimpleDateFormat("HH:mm:ss");
    54                 Main.map.mapView.addMouseListener(this);
     40    private List<WayPoint> gpsTrack;
     41    private ImageIcon layerIcon;
     42    private DateFormat gpsTimeFormat;
     43    private WayPoint iconPosition;
     44    private final int GPS_INTERVALL=1000;
     45    private GPSVideoPlayer gpsVideoPlayer;
     46    private boolean autoCenter;
     47
     48    public VideoPositionLayer(GpxLayer gpsLayer) {
     49        super("videolayer");
     50        layerIcon = new ImageIcon("images/videomapping.png");
     51        gpsTrack=importGPSLayer(gpsLayer.data);
     52        gpsTimeFormat= new SimpleDateFormat("HH:mm:ss");
     53        Main.map.mapView.addMouseListener(this);
    5554        Main.map.mapView.addMouseMotionListener(this);
    5655        iconPosition=gpsTrack.get(0);
    5756        Main.main.addLayer(this);       
    58                
    59         }
    60 
    61         //make a flat copy
    62         private List<WayPoint> importGPSLayer(GpxData gps) {
    63                 LinkedList<WayPoint> ls = new LinkedList<WayPoint>();
     57    }
     58
     59    //make a flat copy
     60    private List<WayPoint> importGPSLayer(GpxData gps) {
     61        LinkedList<WayPoint> ls = new LinkedList<WayPoint>();
    6462        for (GpxTrack trk : gps.tracks) {
    6563            for (GpxTrackSegment segment : trk.getSegments()) {
    … …  
    6967        Collections.sort(ls); //sort basing upon time
    7068        return ls;
    71         }
    72 
    73         @Override
    74         public void paint(Graphics2D g, MapView map, Bounds bound) {
    75                 paintGpsTrack(g, map);
    76                 paintSyncedTrack(g, map);
    77                 paintPositionIcon(g, map);
    78                 //paintInterpolatedSegment(g); //just a test for my own
    79         }
    80 
    81         private void paintGpsTrack(Graphics2D g, MapView map) {
    82                 g.setColor(Color.YELLOW);
     69    }
     70
     71    @Override
     72    public void paint(Graphics2D g, MapView map, Bounds bound) {
     73        paintGpsTrack(g, map);
     74        paintSyncedTrack(g, map);
     75        paintPositionIcon(g, map);
     76        //paintInterpolatedSegment(g); //just a test for my own
     77    }
     78
     79    private void paintGpsTrack(Graphics2D g, MapView map) {
     80        g.setColor(Color.YELLOW);
    8381        for(WayPoint n: gpsTrack) {
    8482            Point p = map.getPoint(n.getEastNorth());
    8583            g.drawOval(p.x - 2, p.y - 2, 4, 4);
    8684        }
    87         }
    88        
    89         private void paintSyncedTrack(Graphics2D g, MapView map) {
    90                 g.setColor(Color.GREEN);
    91                 for (WayPoint n : gpsTrack) {
    92                         if (n.attr.containsKey("synced"))
    93                         {
    94                                 Point p = map.getPoint(n.getEastNorth());
    95                     g.drawOval(p.x - 2, p.y - 2, 4, 4);
    96                         }                               
    97                 }
    98                
    99         }
    100 
    101         private void paintPositionIcon(Graphics2D g, MapView map) {
    102                 Point p=map.getPoint(iconPosition.getEastNorth());
    103         layerIcon.paintIcon(null, g, p.x-layerIcon.getIconWidth()/2, p.y-layerIcon.getIconHeight()/2);
    104         g.drawString(gpsTimeFormat.format(iconPosition.getTime()),p.x-15,p.y-15);
    105         }
    106 /*     
    107         private void paintInterpolatedSegment(Graphics2D g) {
    108                 g.setColor(Color.CYAN);
    109                 List<WayPoint>ls=getInterpolatedSegment(iconPosition,5,5);
     85    }
     86   
     87    private void paintSyncedTrack(Graphics2D g, MapView map) {
     88        g.setColor(Color.GREEN);
     89        for (WayPoint n : gpsTrack) {
     90            if (n.attr.containsKey("synced")) {
     91                Point p = map.getPoint(n.getEastNorth());
     92                g.drawOval(p.x - 2, p.y - 2, 4, 4);
     93            }               
     94        }
     95    }
     96
     97    private void paintPositionIcon(Graphics2D g, MapView map) {
     98        if (iconPosition != null) {
     99            Point p = map.getPoint(iconPosition.getEastNorth());
     100            layerIcon.paintIcon(null, g, p.x-layerIcon.getIconWidth()/2, p.y-layerIcon.getIconHeight()/2);
     101            g.drawString(gpsTimeFormat.format(iconPosition.getTime()),p.x-15,p.y-15);
     102        }
     103    }
     104/*   
     105    private void paintInterpolatedSegment(Graphics2D g) {
     106        g.setColor(Color.CYAN);
     107        List<WayPoint>ls=getInterpolatedSegment(iconPosition,5,5);
    110108        for(WayPoint n: ls) {
    111109            Point p = Main.map.mapView.getPoint(n.getEastNorth());
    112110            g.drawOval(p.x - 2, p.y - 2, 4, 4);
    113111        }
    114                
    115         }
    116 
    117         //just a Demo to show up IPO on a whole segment
    118         private List<WayPoint> getInterpolatedSegment(WayPoint center, int before, int after) {
    119                 LinkedList<WayPoint> ls = new LinkedList<WayPoint>();
    120                 if(gpsTrack.indexOf(iconPosition)!=0)
    121                 {
    122                         WayPoint prev=gpsTrack.get(gpsTrack.indexOf(iconPosition)-1);
    123                         for(int i=1;i<=before;i++)
    124                         {
    125                                 ls.add(interpolate(prev,(float)100f/before*i));
    126                         }
    127                 }
    128                 for(int i=1;i<=after;i++)
    129                 {
    130                         ls.add(interpolate(iconPosition,(float)100f/before*i));
    131                 }
    132                 //test code
    133                 Date test=getFirstWayPoint().getTime();
    134                 test.setHours(14);
    135                 test.setMinutes(50);
    136                 test.setSeconds(33);           
    137                 ls.add(getWayPointBefore(new Date(test.getTime()+500)));
    138                 ls.add(interpolate(new Date(test.getTime()+500)));
    139                 return ls;
    140         }
    141 */     
    142         //creates a waypoint for the corresponding time
    143         public WayPoint interpolate(Date GPSTime)
    144         {
    145                 WayPoint before =getWayPointBefore(GPSTime);
    146                 long diff=GPSTime.getTime()-before.getTime().getTime();
    147                 assert diff>=0;
    148                 assert diff<GPS_INTERVALL;
    149                 float perc=((float)diff/(float)GPS_INTERVALL)*100;             
    150                 return interpolate(before,perc);
    151         }
    152        
    153         public WayPoint getWayPointBefore(Date GPSTime)
    154         {
    155                 assert GPSTime.after(getFirstWayPoint().getTime())==true;
    156                 assert GPSTime.before(getLastWayPoint().getTime())==true;
    157                
    158                 Date first=getFirstWayPoint().getTime();
    159                 long diff=GPSTime.getTime()-first.getTime();
    160                 //assumes that GPS intervall is constant
    161                 int id=(int) (diff/GPS_INTERVALL);             
    162                 return gpsTrack.get(id);
    163         }
    164        
    165         public WayPoint getFirstWayPoint()
    166         {
    167                 return gpsTrack.get(0);
    168         }
    169        
    170         public WayPoint getLastWayPoint()
    171         {
    172                 return gpsTrack.get(gpsTrack.size()-1);
    173         }
    174 
    175         //interpolates a waypoint between this and the following waypoint at percent
    176         private WayPoint interpolate(WayPoint first, float percent) {
    177                 assert (percent>0);
    178                 assert (percent<100);
    179                 double dX,dY;
     112       
     113    }
     114
     115    //just a Demo to show up IPO on a whole segment
     116    private List<WayPoint> getInterpolatedSegment(WayPoint center, int before, int after) {
     117        LinkedList<WayPoint> ls = new LinkedList<WayPoint>();
     118        if(gpsTrack.indexOf(iconPosition)!=0)
     119        {
     120            WayPoint prev=gpsTrack.get(gpsTrack.indexOf(iconPosition)-1);
     121            for(int i=1;i<=before;i++)
     122            {
     123                ls.add(interpolate(prev,(float)100f/before*i));
     124            }
     125        }
     126        for(int i=1;i<=after;i++)
     127        {
     128            ls.add(interpolate(iconPosition,(float)100f/before*i));
     129        }
     130        //test code
     131        Date test=getFirstWayPoint().getTime();
     132        test.setHours(14);
     133        test.setMinutes(50);
     134        test.setSeconds(33);       
     135        ls.add(getWayPointBefore(new Date(test.getTime()+500)));
     136        ls.add(interpolate(new Date(test.getTime()+500)));
     137        return ls;
     138    }
     139*/   
     140    //creates a waypoint for the corresponding time
     141    public WayPoint interpolate(Date GPSTime) {
     142        WayPoint before = getWayPointBefore(GPSTime);
     143        if (before == null) {
     144            return null;
     145        }
     146        long diff = GPSTime.getTime() - before.getTime().getTime();
     147        assert diff>=0;
     148        assert diff<GPS_INTERVALL;
     149        float perc=((float)diff/(float)GPS_INTERVALL)*100;       
     150        return interpolate(before,perc);
     151    }
     152   
     153    public WayPoint getWayPointBefore(Date GPSTime) {
     154        assert GPSTime.after(getFirstWayPoint().getTime())==true;
     155        assert GPSTime.before(getLastWayPoint().getTime())==true;
     156       
     157        Date first=getFirstWayPoint().getTime();
     158        long diff=GPSTime.getTime()-first.getTime();
     159        //assumes that GPS intervall is constant
     160        int id = (int) (diff/GPS_INTERVALL);       
     161        return 0 <= id && id < gpsTrack.size() ? gpsTrack.get(id) : null;
     162    }
     163   
     164    public WayPoint getFirstWayPoint() {
     165        return gpsTrack.isEmpty() ? null : gpsTrack.get(0);
     166    }
     167   
     168    public WayPoint getLastWayPoint() {
     169        return gpsTrack.isEmpty() ? null : gpsTrack.get(gpsTrack.size()-1);
     170    }
     171
     172    //interpolates a waypoint between this and the following waypoint at percent
     173    private WayPoint interpolate(WayPoint first, float percent) {
     174        assert (percent>0);
     175        assert (percent<100);
     176        double dX,dY;
    180177        WayPoint leftP,rightP;
    181        
    182178       
    183179        WayPoint next=gpsTrack.get(gpsTrack.indexOf(first)+1);       
    … …  
    190186        dY=(rightP.getCoor().lat()-leftP.getCoor().lat())*percent;
    191187        //move in the right direction
    192         if (first==leftP)
    193         {
    194                 return new WayPoint(new LatLon(leftP.getCoor().lat()+dY,leftP.getCoor().lon()+dX));
    195         }
    196         else
    197                  return new WayPoint(new LatLon(rightP.getCoor().lat()-dY,rightP.getCoor().lon()-dX));
    198 
    199        
    200         }
    201        
    202         private WayPoint getLeftPoint(WayPoint p1,WayPoint p2)
    203     {
     188        if (first==leftP) {
     189            return new WayPoint(new LatLon(leftP.getCoor().lat()+dY,leftP.getCoor().lon()+dX));
     190        } else {
     191            return new WayPoint(new LatLon(rightP.getCoor().lat()-dY,rightP.getCoor().lon()-dX));
     192        }
     193    }
     194   
     195    private WayPoint getLeftPoint(WayPoint p1,WayPoint p2) {
    204196        if(p1.getCoor().lon()<p2.getCoor().lon()) return p1; else return p2;
    205197    }
    206198   
    207     private WayPoint getRightPoint(WayPoint p1, WayPoint p2)
    208     {
     199    private WayPoint getRightPoint(WayPoint p1, WayPoint p2) {
    209200        if(p1.getCoor().lon()>p2.getCoor().lon()) return p1; else return p2;
    210201    }
    211202   
    212     public Date getGPSDate()
    213     {
    214         return iconPosition.getTime();
    215     }
    216    
    217     public WayPoint getCurrentWayPoint()
    218     {
    219         return iconPosition;
    220     }
    221 
    222 
    223 
    224         public List<WayPoint> getTrack() {
    225                 return gpsTrack;
    226                
    227         }
    228        
    229         public void jump(Date GPSTime)
    230         {
    231                 setIconPosition(getWayPointBefore(GPSTime));
    232                
    233         }
    234 
    235         public void setIconPosition(WayPoint wp) {
    236                 iconPosition=wp;
    237                 Main.map.mapView.repaint();
    238                 if (autoCenter)
    239                         Main.map.mapView.zoomTo(iconPosition.getCoor());
    240                
    241         }
    242 
    243         public void mouseReleased(MouseEvent e) {
    244                 //only leftclicks on our layer
     203    public Date getGPSDate() {
     204        return iconPosition.getTime();
     205    }
     206   
     207    public WayPoint getCurrentWayPoint() {
     208        return iconPosition;
     209    }
     210
     211    public List<WayPoint> getTrack() {
     212        return gpsTrack;
     213    }
     214   
     215    public void jump(Date GPSTime) {
     216        setIconPosition(getWayPointBefore(GPSTime));
     217    }
     218
     219    public void setIconPosition(WayPoint wp) {
     220        iconPosition = wp;
     221        if (Main.isDisplayingMapView()) {
     222            Main.map.mapView.repaint();
     223            if (autoCenter)
     224                Main.map.mapView.zoomTo(iconPosition.getCoor());
     225        }
     226    }
     227
     228    public void mouseReleased(MouseEvent e) {
     229        //only leftclicks on our layer
    245230        if(e.getButton() == MouseEvent.BUTTON1) {
    246                 WayPoint wp = getNearestWayPoint(e.getPoint());                 
    247             if(wp!=null)
    248             {
    249                 if (gpsVideoPlayer.areAllVideosSynced())
    250                 {
    251                         //we set the video to corresponding position
    252                         gpsVideoPlayer.jumpTo(wp.getTime());
    253                 }
    254                 setIconPosition(wp);
     231            WayPoint wp = getNearestWayPoint(e.getPoint());               
     232            if (wp != null) {
     233                if (gpsVideoPlayer.areAllVideosSynced()) {
     234                    //we set the video to corresponding position
     235                    gpsVideoPlayer.jumpTo(wp.getTime());
     236                }
     237                setIconPosition(wp);
    255238            }           
    256239        }
    257                
    258         }
    259 
    260         //finds the first waypoint that is nearby the given point
    261     private WayPoint getNearestWayPoint(Point mouse)
    262     {
     240    }
     241
     242    //finds the first waypoint that is nearby the given point
     243    private WayPoint getNearestWayPoint(Point mouse) {
    263244        final int MAX=10;
    264245        Point p;
    265246        Rectangle rect = new Rectangle(mouse.x-MAX/2,mouse.y-MAX/2,MAX,MAX);
    266247        //iterate through all possible notes
    267         for(WayPoint n : gpsTrack)
    268         {
     248        for(WayPoint n : gpsTrack) {
    269249            p = Main.map.mapView.getPoint(n.getEastNorth());
    270             if (rect.contains(p))
    271             {               
     250            if (rect.contains(p)) {
    272251                return n;
    273252            }
    274            
    275253        }
    276254        return null;
    277        
    278     }
    279 
    280         @Override
    281         public Icon getIcon() {
    282                 return layerIcon;
    283         }
    284 
    285         @Override
    286         public Object getInfoComponent() {
    287                 // TODO Auto-generated method stub
    288                 return null;
    289         }
    290 
    291         @Override
    292         public Action[] getMenuEntries() {
    293                 return new Action[]{
     255    }
     256
     257    @Override
     258    public Icon getIcon() {
     259        return layerIcon;
     260    }
     261
     262    @Override
     263    public Object getInfoComponent() {
     264        // TODO Auto-generated method stub
     265        return null;
     266    }
     267
     268    @Override
     269    public Action[] getMenuEntries() {
     270        return new Action[]{
    294271                LayerListDialog.getInstance().createActivateLayerAction(this),
    295272                LayerListDialog.getInstance().createShowHideLayerAction(),
    … …  
    297274                SeparatorLayerAction.INSTANCE,
    298275                new LayerListPopup.InfoAction(this)};
    299         }
    300 
    301 
    302         @Override
    303         public String getToolTipText() {
    304                 return tr("Shows current position in the video");
    305         }
    306 
    307         @Override
    308         public boolean isMergable(Layer arg0) {         
    309                 return false;
    310         }
    311 
    312         @Override
    313         public void mergeFrom(Layer arg0) {
    314                
    315         }
    316 
    317         @Override
    318         public void visitBoundingBox(BoundingXYVisitor arg0) {
    319                 // TODO Auto-generated method stub
    320                
    321         }
    322 
    323         public void mouseClicked(MouseEvent arg0) {
    324                 // TODO Auto-generated method stub
    325                
    326         }
    327 
    328         public void mouseEntered(MouseEvent arg0) {
    329                 // TODO Auto-generated method stub
    330                
    331         }
    332 
    333         public void mouseExited(MouseEvent arg0) {
    334                 // TODO Auto-generated method stub
    335                
    336         }
    337 
    338         public void mousePressed(MouseEvent e) {
    339         }
    340 
    341         public void mouseDragged(MouseEvent arg0) {
    342                 // TODO Auto-generated method stub
    343                
    344         }
    345 
    346         public void mouseMoved(MouseEvent arg0) {
    347                 // TODO Auto-generated method stub
    348                
    349         }
    350        
    351         public void setGPSVideoPlayer(GPSVideoPlayer player)
    352         {
    353                 gpsVideoPlayer=player;
    354         }
    355 
    356         public void setAutoCenter(boolean enabled) {
    357                 autoCenter=enabled;
    358                
    359         }
    360 
    361         public void unload() {
    362                 Main.main.removeLayer(this);
    363                
    364         }
    365    
     276    }
     277
     278    @Override
     279    public String getToolTipText() {
     280        return tr("Shows current position in the video");
     281    }
     282
     283    @Override
     284    public boolean isMergable(Layer arg0) {       
     285        return false;
     286    }
     287
     288    @Override
     289    public void mergeFrom(Layer arg0) {
     290    }
     291
     292    @Override
     293    public void visitBoundingBox(BoundingXYVisitor arg0) {
     294    }
     295
     296    public void mouseClicked(MouseEvent arg0) {
     297    }
     298
     299    public void mouseEntered(MouseEvent arg0) {
     300    }
     301
     302    public void mouseExited(MouseEvent arg0) {
     303    }
     304
     305    public void mousePressed(MouseEvent e) {
     306    }
     307
     308    public void mouseDragged(MouseEvent arg0) {
     309    }
     310
     311    public void mouseMoved(MouseEvent arg0) {
     312    }
     313   
     314    public void setGPSVideoPlayer(GPSVideoPlayer player) {
     315        gpsVideoPlayer = player;
     316    }
     317
     318    public void setAutoCenter(boolean enabled) {
     319        autoCenter = enabled;
     320    }
     321
     322    public void unload() {
     323        Main.main.removeLayer(this);
     324    }
    366325}

  • applications/editors/josm/plugins/videomapping/src/org/openstreetmap/josm/plugins/videomapping/video/GPSVideo.java

    r28924 r30639  
    1313
    1414// a specific synced video
    15 public class GPSVideo extends Video{
     15public class GPSVideo extends Video {
    1616        private static final String SYNC_KEY = "synced";
    1717        public JComponent SyncComponent;
    … …  
    2828        }
    2929       
    30         public GPSVideo(Video video)
    31         {
     30        public GPSVideo(Video video) {
    3231                super(video.filename, video.id, video.mediaPlayerFactory);
    3332                this.player = video.player;
    … …  
    3635        //calculates attributes basing upon the current position
    3736        public void doSync(VideoPositionLayer layer) {
    38                 this.videoPositionLayer=layer;
     37                this.videoPositionLayer = layer;
    3938                if (isSynced())
    4039                        removeSyncedWayPoints();
    41                 syncWayPoint=layer.getCurrentWayPoint();
    42                 syncVideoTime=getCurrentTime();
     40                syncWayPoint = layer.getCurrentWayPoint();
     41                syncVideoTime = getCurrentTime();
    4342                //calc now, to avoid calculations on every click
    44                 start=new Date(syncWayPoint.getTime().getTime()-syncVideoTime);
    45                 end=new Date(start.getTime()+player.getLength());
    46                 firstWayPoint=getFirstGPS();
    47                 lastWayPoint=getLastGPS();
     43                if (syncWayPoint != null) {
     44                start = new Date(syncWayPoint.getTime().getTime()-syncVideoTime);
     45                end = new Date(start.getTime()+player.getLength());
     46                } else {
     47                    start = null;
     48                    end = null;
     49                }
     50                firstWayPoint = getFirstGPS();
     51                lastWayPoint = getLastGPS();
    4852                markSyncedWayPoints();
    4953                Main.map.mapView.repaint();
    … …  
    5256        //make sure we don't leave the GPS track
    5357        private WayPoint getFirstGPS() {
    54                 if(start.before(videoPositionLayer.getFirstWayPoint().getTime()))
    55                 {
     58                if (start == null || start.before(videoPositionLayer.getFirstWayPoint().getTime())) {
    5659                        return videoPositionLayer.getFirstWayPoint();
    57                 }
    58                 else
    59                 {
     60                } else {
    6061                        return videoPositionLayer.getWayPointBefore(start);
    6162                }
    … …  
    6364       
    6465        //make sure we don't leave the GPS track
    65         private WayPoint getLastGPS() {         
    66                 if(end.after(videoPositionLayer.getLastWayPoint().getTime()))
    67                 {
     66        private WayPoint getLastGPS() {
     67                if (end == null || end.after(videoPositionLayer.getLastWayPoint().getTime())) {
    6868                        return videoPositionLayer.getLastWayPoint();
    69                 }
    70                 else
    71                 {
     69                } else {
    7270                        return videoPositionLayer.getWayPointBefore(end);
    7371                }
    … …  
    7573       
    7674        private void removeSyncedWayPoints() {
    77                 List <WayPoint> track =videoPositionLayer.getTrack();
    78                 int start=track.indexOf(firstWayPoint);
    79                 int end=track.indexOf(lastWayPoint);
    80                 List <WayPoint> ls =videoPositionLayer.getTrack().subList(start, end);
    81                 for (WayPoint n : ls) {
    82                         n.attr.keySet().remove(SYNC_KEY);
    83                 }                               
     75                List <WayPoint> track = videoPositionLayer.getTrack();
     76                int start = track.indexOf(firstWayPoint);
     77                int end = track.indexOf(lastWayPoint);
     78        if (0 <= start && start <= end && end < track.size()) {
     79                for (WayPoint n : track.subList(start, end)) {
     80                        n.attr.keySet().remove(SYNC_KEY);
     81                }
     82        }
    8483        }
    8584
    8685        private void markSyncedWayPoints() {
    87                 List <WayPoint> track =videoPositionLayer.getTrack();
    88                 int start=track.indexOf(firstWayPoint);
    89                 int end=track.indexOf(lastWayPoint);
    90                 List <WayPoint> ls =videoPositionLayer.getTrack().subList(start, end);
    91                 for (WayPoint n : ls) {
    92                         n.attr.put(SYNC_KEY, id);
    93                 }                               
     86                List <WayPoint> track = videoPositionLayer.getTrack();
     87                int start = track.indexOf(firstWayPoint);
     88                int end = track.indexOf(lastWayPoint);
     89                if (0 <= start && start <= end && end < track.size()) {
     90                for (WayPoint n : track.subList(start, end)) {
     91                        n.attr.put(SYNC_KEY, id);
     92                }
     93                }
    9494        }
    9595
    9696        public boolean isSynced() {
    97                 return firstWayPoint!=null;
     97                return syncWayPoint != null;
    9898        }
    9999
    100100        //if synced jump in video to this GPS timecode
    101101        public void jumpTo(Date GPSTime) {
    102                 if((GPSTime.after(firstWayPoint.getTime())&(GPSTime.before(lastWayPoint.getTime()))))
    103                 {
    104                         long diff=GPSTime.getTime()-start.getTime();
     102                if((GPSTime.after(firstWayPoint.getTime())&(GPSTime.before(lastWayPoint.getTime())))) {
     103                        long diff = GPSTime.getTime()-start.getTime();
    105104                        player.setTime(diff);
    106105                        System.out.println(diff);
    … …  
    108107        }
    109108       
    110         public WayPoint getCurrentWayPoint()
    111         {
    112                 if (isSynced())
    113                 {
    114                         long videotime=player.getTime();
    115                         Date gpstime=new Date(start.getTime()+videotime);
     109        public WayPoint getCurrentWayPoint() {
     110                if (isSynced()) {
     111                        long videotime = player.getTime();
     112                        Date gpstime = new Date(start.getTime()+videotime);
    116113                        return videoPositionLayer.interpolate(gpstime);
    117114                }
    118115                return null;
    119116        }
    120 
    121117}

  • applications/editors/josm/plugins/videomapping/src/org/openstreetmap/josm/plugins/videomapping/video/GPSVideoPlayer.java

    r29769 r30639  
    1818
    1919//extends video playback, major control has the video player
    20 public class GPSVideoPlayer extends VideoPlayer
    21 {
     20public class GPSVideoPlayer extends VideoPlayer {
    2221        private List<GPSVideo> videos;
    2322        private VideoPositionLayer videoPositionLayer;
    … …  
    6968       
    7069        //jump in all videos this date, if possible
    71         public void jumpTo(Date date)
    72         {
     70        public void jumpTo(Date date) {
    7371                for (GPSVideo video : videos) {
    7472                        video.jumpTo(date);
    … …  
    7674        }
    7775       
    78         public boolean areAllVideosSynced()
    79         {
     76        public boolean areAllVideosSynced() {
    8077                for (GPSVideo video : videos) {
    8178                        if (!video.isSynced()) return false;
    … …  
    8380                return true;           
    8481        }
    85 
    8682
    8783        @Override
    … …  
    9793                super.windowClosing(arg0);
    9894        }
    99        
    100        
    101        
    102        
    103    
    104    
    105 
    106 
    107    
    108    
    109 
    110    
    11195}

  • applications/editors/josm/plugins/videomapping/src/org/openstreetmap/josm/plugins/videomapping/video/VideoPlayer.java

    r29769 r30639  
    2828import javax.swing.event.ChangeListener;
    2929
     30import org.openstreetmap.josm.gui.util.GuiHelper;
     31
    3032import uk.co.caprica.vlcj.player.DeinterlaceMode;
    3133
    … …  
    3335 */
    3436public class VideoPlayer extends JFrame implements WindowListener, VideosObserver, VideoPlayerObserver {
    35         private static final int notificationIntervall = 500;
    36         protected JPanel screenPanel,controlsPanel,canvasPanel;
     37    private static final int notificationIntervall = 500;
     38    protected JPanel screenPanel,controlsPanel,canvasPanel;
    3739    private JSlider timeline;
    3840    private JButton play,back,forward;
    … …  
    4345    private long jumpLength;
    4446    private long loopLength;
    45         private Timer loopingTimer;
    46         private boolean isManualJump;
    47         private Timer notificationTimer;
    48         private List<VideoPlayerObserver> observers;
    49        
    50         public VideoPlayer(DateFormat videoTimeFormat) throws HeadlessException {
    51                 super();               
    52 //              this.videoTimeFormat=videoTimeFormat;
    53                 //setup playback notifications
    54                 videoengine=new VideoEngine(this);
    55                 videoengine.addObserver(this);
    56                 observers=new LinkedList<VideoPlayerObserver>();               
    57                 addObserver(this);
    58                 //setup GUI
    59             setSize(400, 300); //later we apply movie size
    60             setAlwaysOnTop(true);
    61             createUI();
    62             addUI();
    63             addUIListeners();   
    64             setVisible(true);
    65             setAlwaysOnTop(true);          
    66             this.addWindowListener(this);
    67         }
    68        
    69         public Video addVideo(File videofile, String id) {
    70                 Video video = new Video(videofile,id,videoengine.mediaPlayerFactory);
    71                 canvasPanel.add(video.panel);
    72                 video.canvas.setSize(new Dimension(300, 300)); // will be updated by the video engine itself
    73                 videoengine.add(video);
     47    private Timer loopingTimer;
     48    private boolean isManualJump;
     49    private Timer notificationTimer;
     50    private List<VideoPlayerObserver> observers;
     51   
     52    public VideoPlayer(DateFormat videoTimeFormat) throws HeadlessException {
     53        super();       
     54//        this.videoTimeFormat=videoTimeFormat;
     55        //setup playback notifications
     56        videoengine=new VideoEngine(this);
     57        videoengine.addObserver(this);
     58        observers=new LinkedList<VideoPlayerObserver>();       
     59        addObserver(this);
     60        //setup GUI
     61        setSize(400, 300); //later we apply movie size
     62        setAlwaysOnTop(true);
     63        createUI();
     64        addUI();
     65        addUIListeners();   
     66        setVisible(true);
     67        setAlwaysOnTop(true);       
     68        this.addWindowListener(this);
     69    }
     70   
     71    public Video addVideo(File videofile, String id) {
     72        Video video = new Video(videofile,id,videoengine.mediaPlayerFactory);
     73        canvasPanel.add(video.panel);
     74        video.canvas.setSize(new Dimension(300, 300)); // will be updated by the video engine itself
     75        videoengine.add(video);
    7476        pack();
    7577        startNotificationTimer();
    7678        return video;
    77         }
    78        
    79         public List <Video> getVideos()
    80         {
    81                 return videoengine.getVideos();
    82         }
    83 
    84        
    85         public void pause() {
    86                 videoengine.pause();
    87                 if (videoengine.isNoVideoPlaying())
    88                         stopNotificationTimer();
    89                 else
    90                         startNotificationTimer();
    91         }
    92        
    93         public void pauseAll()
    94         {
    95                 stopNotificationTimer();
    96                 videoengine.pauseAll();
    97         }
    98 
    99         public void backward() {
    100                 videoengine.jumpFor(-jumpLength);       
    101         }
    102 
    103         public void forward() {
    104                 videoengine.jumpFor(jumpLength);       
    105         }
    106 
    107         public void setSpeed(Integer percent)
    108         {
    109                 speed.setValue(percent);               
    110         }
    111        
    112         public Integer getSpeed()
    113         {
    114                 return speed.getValue();
    115         }
    116        
    117         public void setDeinterlacer(DeinterlaceMode deinterlacer)
    118         {
    119                 videoengine.setDeinterlacer(deinterlacer);
    120         }
    121        
    122         public void setSubtitles(boolean enabled)
    123         {
    124                 videoengine.setSubtitles(enabled);
    125         }
    126 
    127         public void mute()
    128         {
    129                 videoengine.mute();
    130         }
    131 
    132         //TODO auf mehrere Videos umstellen
    133         public void toggleLooping() {
    134                 if(loopingTimer==null)
    135                 {
    136                         //do reset after loop time experienced
    137                         final long videoResetTime=(long) videoengine.getVideoTime()-loopLength/2;
    138                         TimerTask reset=new TimerTask() {               
     79    }
     80   
     81    public List <Video> getVideos() {
     82        return videoengine.getVideos();
     83    }
     84   
     85    public void pause() {
     86        videoengine.pause();
     87        if (videoengine.isNoVideoPlaying())
     88            stopNotificationTimer();
     89        else
     90            startNotificationTimer();
     91    }
     92   
     93    public void pauseAll() {
     94        stopNotificationTimer();
     95        videoengine.pauseAll();
     96    }
     97
     98    public void backward() {
     99        videoengine.jumpFor(-jumpLength);   
     100    }
     101
     102    public void forward() {
     103        videoengine.jumpFor(jumpLength);   
     104    }
     105
     106    public void setSpeed(Integer percent) {
     107        speed.setValue(percent);       
     108    }
     109   
     110    public Integer getSpeed() {
     111        return speed.getValue();
     112    }
     113   
     114    public void setDeinterlacer(DeinterlaceMode deinterlacer) {
     115        videoengine.setDeinterlacer(deinterlacer);
     116    }
     117   
     118    public void setSubtitles(boolean enabled) {
     119        videoengine.setSubtitles(enabled);
     120    }
     121
     122    public void mute() {
     123        videoengine.mute();
     124    }
     125
     126    //TODO auf mehrere Videos umstellen
     127    public void toggleLooping() {
     128        if (loopingTimer==null) {
     129            //do reset after loop time experienced
     130            final long videoResetTime = (long) videoengine.getVideoTime()-loopLength/2;
     131            TimerTask reset = new TimerTask() {               
    139132                @Override
    140133                public void run() {
    … …  
    144137            loopingTimer= new Timer();
    145138            loopingTimer.schedule(reset,loopLength/2,loopLength);
     139        } else {
     140            loopingTimer.cancel();
     141            loopingTimer=null;
    146142        }
    147                 else
    148                 {
    149                         loopingTimer.cancel();
    150                         loopingTimer=null;
    151                 }
    152                
    153         }
    154 
    155         //create all normal player controls
    156         private void createUI() {
     143    }
     144
     145    //create all normal player controls
     146    private void createUI() {
    157147        //setIconImage();
    158148        timeline = new JSlider(0,100,0);
    … …  
    176166        speed.setPaintLabels(true);
    177167    }
    178        
    179         //puts all player controls to screen
    180         private void addUI() {
    181                 //create layouts
     168   
     169    //puts all player controls to screen
     170    private void addUI() {
     171        //create layouts
    182172        this.setLayout(new BorderLayout());
    183173        screenPanel=new JPanel();
    … …  
    201191        mute.setSelected(false);
    202192    }
    203        
    204         //add UI functionality
     193   
     194    //add UI functionality
    205195    private void addUIListeners() {       
    206196       
    207197        play.addActionListener(new ActionListener() {           
    208             @Override public void actionPerformed(ActionEvent arg0) {
    209             pause();               
     198            @Override
     199            public void actionPerformed(ActionEvent arg0) {
     200                pause();               
    210201            }
    211202        });
    212203       
    213204        back.addActionListener(new ActionListener() {
    214            
    215             @Override public void actionPerformed(ActionEvent arg0) {
     205            @Override
     206            public void actionPerformed(ActionEvent arg0) {
    216207                backward();
    217208            }
    … …  
    219210       
    220211        forward.addActionListener(new ActionListener() {
    221            
    222             @Override public void actionPerformed(ActionEvent arg0) {
     212            @Override
     213            public void actionPerformed(ActionEvent arg0) {
    223214                forward();
    224215            }
    … …  
    226217       
    227218        loop.addActionListener(new ActionListener() {
    228 
    229             @Override public void actionPerformed(ActionEvent arg0) {
     219            @Override
     220            public void actionPerformed(ActionEvent arg0) {
    230221                toggleLooping();
    231222            }
    … …  
    233224       
    234225        mute.addActionListener(new ActionListener() {
    235 
    236             @Override public void actionPerformed(ActionEvent arg0) {
     226            @Override
     227            public void actionPerformed(ActionEvent arg0) {
    237228                mute();
    238229            }
    … …  
    242233            @Override
    243234            public void stateChanged(ChangeEvent e) {
    244                         //skip events, fired by this sliede, one cycle ago             
    245                 if(!isManualJump)
    246                 {
    247                         isManualJump=true;
    248                         videoengine.jumpToPosition((timeline.getValue()));
    249                         System.out.println("manual jump");
    250                 }
    251             }
     235                //skip events, fired by this sliede, one cycle ago               
     236                if (!isManualJump) {
     237                    isManualJump = true;
     238                    videoengine.jumpToPosition((timeline.getValue()));
     239                }
     240            }
     241        });
     242       
     243        speed.addChangeListener(new ChangeListener() {           
     244            @Override
     245            public void stateChanged(ChangeEvent arg0) {                           
     246                if(!speed.getValueIsAdjusting()) {
     247                    videoengine.setSpeed(speed.getValue());
     248                }
     249            }
     250        });
     251    }
     252   
     253    public void setJumpLength(long ms) {
     254        jumpLength = ms;
     255    }
     256   
     257    public void setLoopLength(long ms) {
     258        loopLength = ms;
     259    }
     260   
     261    public void enableSingleVideoMode(boolean enabled) {
     262        pauseAll();
     263        videoengine.enableSingleVideoMode(enabled);
     264    }
     265   
     266    public void addObserver(VideoPlayerObserver observer) {
     267        observers.add(observer);
     268    }
     269   
     270    private void stopNotificationTimer() {
     271        /*
     272        if(notificationTimer!=null)
     273        {
     274            notificationTimer.cancel();
     275            notificationTimer=null;
     276        }
     277        */
     278    }
     279
     280    private void startNotificationTimer() {
     281        notificationTimer= new Timer();
     282        notificationTimer.schedule(new TimerTask() {               
     283            @Override
     284            public void run() {
     285                notifyObservers();
    252286               
    253         });
    254        
    255         speed.addChangeListener(new ChangeListener() {           
    256             @Override
    257             public void stateChanged(ChangeEvent arg0) {                           
    258                 if(!speed.getValueIsAdjusting())
    259                 {
    260                         videoengine.setSpeed(speed.getValue());
    261                 }
    262             }
    263         });
    264        
    265     }
    266    
    267     public void setJumpLength(long ms)
    268     {
    269         jumpLength=ms;
    270     }
    271    
    272     public void setLoopLength(long ms)
    273     {
    274         loopLength=ms;
    275     }
    276    
    277     public void enableSingleVideoMode(boolean enabled)
    278     {
    279         pauseAll();
    280         videoengine.enableSingleVideoMode(enabled);
    281     }
    282    
    283     public void addObserver(VideoPlayerObserver observer)
    284     {
    285         observers.add(observer);
    286     }
    287        
    288        
    289         private void stopNotificationTimer() {
    290                 /*
    291                 if(notificationTimer!=null)
    292                 {
    293                         notificationTimer.cancel();
    294                         notificationTimer=null;
    295                 }
    296                 */
    297         }
    298 
    299         private void startNotificationTimer() {
    300                 notificationTimer= new Timer();
    301                 notificationTimer.schedule(new TimerTask() {                           
    302                         @Override
    303                         public void run() {
    304                                 notifyObservers();
    305                                
    306                         }
    307                 },notificationIntervall,notificationIntervall);
    308         }
    309        
    310         private void  notifyObservers() {
    311                 for (VideoPlayerObserver observer : observers) {
    312                         observer.update_plays();//TODO hier müssten gleich die Zeiten übergeben werden
    313                 }
    314         }
    315 
    316         @Override
    317         public void windowActivated(WindowEvent arg0) { }
    318 
    319         @Override
    320         public void windowClosed(WindowEvent arg0) { }
    321 
    322         @Override
    323         public void windowClosing(WindowEvent arg0) {   
    324                 videoengine.unload();
    325         }
    326 
    327         @Override
    328         public void windowDeactivated(WindowEvent arg0) { }
    329 
    330         @Override
    331         public void windowDeiconified(WindowEvent arg0) { }
    332 
    333         @Override
    334         public void windowIconified(WindowEvent arg0) { }
    335 
    336         @Override
    337         public void windowOpened(WindowEvent arg0) { }
    338 
    339         @Override
    340         public void update(VideoObserversEvents event) {
    341             switch (event)
    342             {           
    343                 case resizing:
    344                 {
    345                     pack();
    346                     break;
    347                 }
    348                 case speeding:
    349                 {
    350                     speed.setValue(videoengine.getSpeed());
    351                     break;
    352                 }
    353                 case jumping:
    354                 {                       
    355                     break;
    356                 }
    357             }           
    358         }
    359 
    360         //keep internal controls up to date during playback
    361         @Override
    362         public void update_plays() {
    363                 timeline.setValue(videoengine.getPosition());
    364                 setTitle(Long.toString(videoengine.getVideoTime()));
    365                 isManualJump=false;
    366                 System.out.println("update");
    367                
    368         }
    369    
    370         public boolean isCorrectlyInitiliazed() {
    371             return videoengine != null && videoengine.mediaPlayerFactory != null;
    372         }
     287            }
     288        },notificationIntervall,notificationIntervall);
     289    }
     290   
     291    private void  notifyObservers() {
     292        for (VideoPlayerObserver observer : observers) {
     293            observer.update_plays();//TODO hier müssten gleich die Zeiten übergeben werden
     294        }
     295    }
     296
     297    @Override
     298    public void windowActivated(WindowEvent arg0) { }
     299
     300    @Override
     301    public void windowClosed(WindowEvent arg0) { }
     302
     303    @Override
     304    public void windowClosing(WindowEvent arg0) {   
     305        videoengine.unload();
     306    }
     307
     308    @Override
     309    public void windowDeactivated(WindowEvent arg0) { }
     310
     311    @Override
     312    public void windowDeiconified(WindowEvent arg0) { }
     313
     314    @Override
     315    public void windowIconified(WindowEvent arg0) { }
     316
     317    @Override
     318    public void windowOpened(WindowEvent arg0) { }
     319
     320    @Override
     321    public void update(VideoObserversEvents event) {
     322        switch (event)
     323        {       
     324            case resizing:
     325            {
     326                pack();
     327                break;
     328            }
     329            case speeding:
     330            {
     331                speed.setValue(videoengine.getSpeed());
     332                break;
     333            }
     334            case jumping:
     335            {           
     336                break;
     337            }
     338        }       
     339    }
     340
     341    //keep internal controls up to date during playback
     342    @Override
     343    public void update_plays() {
     344        GuiHelper.runInEDT(new Runnable() {
     345            @Override
     346            public void run() {
     347                timeline.setValue(videoengine.getPosition());
     348                setTitle(Long.toString(videoengine.getVideoTime()));
     349            }
     350        });
     351        isManualJump = false;
     352    }
     353   
     354    public boolean isCorrectlyInitiliazed() {
     355        return videoengine != null && videoengine.mediaPlayerFactory != null;
     356    }
    373357}
Note: See TracChangeset for help on using the changeset viewer.