001/*
002 * This file is part of McIDAS-V
003 *
004 * Copyright 2007-2016
005 * Space Science and Engineering Center (SSEC)
006 * University of Wisconsin - Madison
007 * 1225 W. Dayton Street, Madison, WI 53706, USA
008 * https://www.ssec.wisc.edu/mcidas
009 * 
010 * All Rights Reserved
011 * 
012 * McIDAS-V is built on Unidata's IDV and SSEC's VisAD libraries, and
013 * some McIDAS-V source code is based on IDV and VisAD source code.  
014 * 
015 * McIDAS-V is free software; you can redistribute it and/or modify
016 * it under the terms of the GNU Lesser Public License as published by
017 * the Free Software Foundation; either version 3 of the License, or
018 * (at your option) any later version.
019 * 
020 * McIDAS-V is distributed in the hope that it will be useful,
021 * but WITHOUT ANY WARRANTY; without even the implied warranty of
022 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
023 * GNU Lesser Public License for more details.
024 * 
025 * You should have received a copy of the GNU Lesser Public License
026 * along with this program.  If not, see http://www.gnu.org/licenses.
027 */
028
029package edu.wisc.ssec.mcidasv.data.cyclone;
030
031import java.util.ArrayList;
032import java.util.HashMap;
033import java.util.Iterator;
034import java.util.List;
035import java.util.Set;
036
037import visad.DateTime;
038
039/**
040 * Created by IntelliJ IDEA. User: yuanho Date: Apr 9, 2008 Time: 5:00:40 PM To
041 * change this template use File | Settings | File Templates.
042 */
043
044public class StormTrackCollection {
045
046        /** _more_ */
047        // private HashMap forecastWayMapStartDates;
048
049        /** _more_ */
050        // private StormTrack obsTrack;
051
052        /** _more_ */
053        private HashMap<Way, List> wayToTracksHashMap;
054
055        /** _more_ */
056        List<StormTrack> tracks = new ArrayList<StormTrack>();
057
058        /**
059         * _more_
060         */
061        public StormTrackCollection() {
062                wayToTracksHashMap = new HashMap<Way, List>();
063                // forecastWayMapStartDates = new HashMap();
064                // obsTrack = null;
065        }
066
067        /**
068         * _more_
069         * 
070         * 
071         * @return _more_
072         */
073        public List<Way> getWayList() {
074                Set ss = wayToTracksHashMap.keySet();
075                ArrayList ways = new ArrayList();
076                ways.addAll(ss);
077                return ways;
078        }
079
080        /**
081         * _more_
082         * 
083         * @param tracks
084         *            _more_
085         */
086        public void addTrackList(List<StormTrack> tracks) {
087                for (StormTrack track : tracks) {
088                        addTrack(track);
089                }
090        }
091
092        /**
093         * _more_
094         * 
095         * @param track
096         *            _more_
097         */
098        public void addTrack(StormTrack track) {
099                List list = wayToTracksHashMap.get(track.getWay());
100                if (list == null) {
101                        wayToTracksHashMap.put(track.getWay(),
102                                        list = new ArrayList<StormTrack>());
103
104                }
105                list.add(track);
106                tracks.add(track);
107        }
108
109        /**
110         * _more_
111         * 
112         * @return _more_
113         */
114        public List<StormTrack> getTracks() {
115                return new ArrayList<StormTrack>(tracks);
116        }
117
118        /**
119         * _more_
120         * 
121         * 
122         * @param way
123         *            _more_
124         * @return _more_
125         */
126        public List<StormTrack> getTrackList(Way way) {
127                return (List<StormTrack>) wayToTracksHashMap.get(way);
128        }
129
130        /**
131         * _more_
132         * 
133         * @return _more_
134         */
135        public HashMap<Way, List> getWayToTracksHashMap() {
136                return wayToTracksHashMap;
137        }
138
139        /**
140         * _more_
141         * 
142         * @return _more_
143         */
144        public HashMap getWayToStartDatesHashMap() {
145                HashMap wayToStartDatesHashMap = new HashMap();
146                int size = wayToTracksHashMap.size();
147                Set ways = wayToTracksHashMap.keySet();
148                Iterator itr = ways.iterator();
149                for (int i = 0; i < size; i++) {
150                        Way way = (Way) itr.next();
151                        List tracks = getTrackList(way);
152                        List startTimes = new ArrayList();
153                        if (tracks != null) {
154                                Iterator its = tracks.iterator();
155                                while (its.hasNext()) {
156                                        StormTrack track = (StormTrack) its.next();
157                                        DateTime st = track.getStartTime();
158                                        startTimes.add(st);
159                                }
160                                if (startTimes.size() > 0) {
161                                        wayToStartDatesHashMap.put(way, startTimes);
162                                }
163                        }
164
165                }
166                return wayToStartDatesHashMap;
167        }
168
169        /**
170         * _more_
171         * 
172         * @return _more_
173         */
174        public StormTrack getObsTrack() {
175                List tracks = getTrackList(Way.OBSERVATION);
176                if ((tracks == null) || (tracks.size() == 0)) {
177                        return null;
178                }
179                return (StormTrack) tracks.get(0);
180        }
181
182        /**
183         * _more_
184         * 
185         * 
186         * @param way
187         *            _more_
188         */
189        public void setObsTrack(Way way) {
190                // first remove the obs track
191                List<StormTrack> obtracks = wayToTracksHashMap.get(Way.OBSERVATION);
192                StormTrack obtrack = obtracks.get(0);
193                StormInfo sInfo = obtrack.getStormInfo();
194                List<StormParam> obParams = obtrack.getParams();
195                int size = obParams.size();
196                StormParam[] obParam = new StormParam[size];
197                int i = 0;
198                for (StormParam sp : obParams) {
199                        obParam[i] = sp;
200                        i++;
201                }
202                wayToTracksHashMap.remove(Way.OBSERVATION);
203
204                // now construct the obs track
205                List<StormTrackPoint> newObsPoints = new ArrayList();
206                List<StormTrack> tracks = getTrackList(way);
207
208                for (StormTrack stk : tracks) {
209                        List<StormTrackPoint> stkPoints = stk.getTrackPoints();
210                        newObsPoints.add(stkPoints.get(0));
211                }
212
213                StormTrack stk = new StormTrack(sInfo, Way.OBSERVATION, newObsPoints,
214                                obParam);
215
216                addTrack(stk);
217        }
218
219}