JAL-2668 fix broken factory method for colour scheme
[jalview.git] / src / jalview / gui / StructureViewer.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.gui;
22
23 import jalview.api.structures.JalviewStructureDisplayI;
24 import jalview.bin.Cache;
25 import jalview.datamodel.PDBEntry;
26 import jalview.datamodel.SequenceI;
27 import jalview.datamodel.StructureViewerModel;
28 import jalview.structure.StructureSelectionManager;
29
30 import java.awt.Rectangle;
31 import java.util.ArrayList;
32 import java.util.HashMap;
33 import java.util.LinkedHashMap;
34 import java.util.List;
35 import java.util.Map;
36 import java.util.Map.Entry;
37
38 /**
39  * A proxy for handling structure viewers, that orchestrates adding selected
40  * structures, associated with sequences in Jalview, to an existing viewer, or
41  * opening a new one. Currently supports either Jmol or Chimera as the structure
42  * viewer.
43  * 
44  * @author jprocter
45  */
46 public class StructureViewer
47 {
48   private static final String UNKNOWN_VIEWER_TYPE = "Unknown structure viewer type ";
49
50   StructureSelectionManager ssm;
51
52   public enum ViewerType
53   {
54     JMOL, CHIMERA
55   };
56
57   /**
58    * Constructor
59    * 
60    * @param structureSelectionManager
61    */
62   public StructureViewer(StructureSelectionManager structureSelectionManager)
63   {
64     ssm = structureSelectionManager;
65   }
66
67   public ViewerType getViewerType()
68   {
69     String viewType = Cache.getDefault(Preferences.STRUCTURE_DISPLAY,
70             ViewerType.JMOL.name());
71     return ViewerType.valueOf(viewType);
72   }
73
74   public void setViewerType(ViewerType type)
75   {
76     Cache.setProperty(Preferences.STRUCTURE_DISPLAY, type.name());
77   }
78
79   /**
80    * View multiple PDB entries, each with associated sequences
81    * 
82    * @param pdbs
83    * @param seqs
84    * @param ap
85    * @return
86    */
87   public JalviewStructureDisplayI viewStructures(PDBEntry[] pdbs,
88           SequenceI[] seqs, AlignmentPanel ap)
89   {
90     JalviewStructureDisplayI viewer = onlyOnePdb(pdbs, seqs, ap);
91     if (viewer != null)
92     {
93       /*
94        * user added structure to an existing viewer - all done
95        */
96       return viewer;
97     }
98
99     ViewerType viewerType = getViewerType();
100
101     Map<PDBEntry, SequenceI[]> seqsForPdbs = getSequencesForPdbs(pdbs,
102             seqs);
103     PDBEntry[] pdbsForFile = seqsForPdbs.keySet().toArray(
104             new PDBEntry[seqsForPdbs.size()]);
105     SequenceI[][] theSeqs = seqsForPdbs.values().toArray(
106             new SequenceI[seqsForPdbs.size()][]);
107     JalviewStructureDisplayI sview = null;
108     if (viewerType.equals(ViewerType.JMOL))
109     {
110       sview = new AppJmol(ap, pdbsForFile, theSeqs);
111     }
112     else if (viewerType.equals(ViewerType.CHIMERA))
113     {
114       sview = new ChimeraViewFrame(pdbsForFile, theSeqs, ap);
115     }
116     else
117     {
118       Cache.log.error(UNKNOWN_VIEWER_TYPE + getViewerType().toString());
119     }
120     return sview;
121   }
122
123   /**
124    * Converts the list of selected PDB entries (possibly including duplicates
125    * for multiple chains), and corresponding sequences, into a map of sequences
126    * for each distinct PDB file. Returns null if either argument is null, or
127    * their lengths do not match.
128    * 
129    * @param pdbs
130    * @param seqs
131    * @return
132    */
133   Map<PDBEntry, SequenceI[]> getSequencesForPdbs(PDBEntry[] pdbs,
134           SequenceI[] seqs)
135   {
136     if (pdbs == null || seqs == null || pdbs.length != seqs.length)
137     {
138       return null;
139     }
140
141     /*
142      * we want only one 'representative' PDBEntry per distinct file name
143      * (there may be entries for distinct chains)
144      */
145     Map<String, PDBEntry> pdbsSeen = new HashMap<>();
146
147     /*
148      * LinkedHashMap preserves order of PDB entries (significant if they
149      * will get superimposed to the first structure)
150      */
151     Map<PDBEntry, List<SequenceI>> pdbSeqs = new LinkedHashMap<>();
152     for (int i = 0; i < pdbs.length; i++)
153     {
154       PDBEntry pdb = pdbs[i];
155       SequenceI seq = seqs[i];
156       String pdbFile = pdb.getFile();
157       if (pdbFile == null || pdbFile.length() == 0)
158       {
159         pdbFile = pdb.getId();
160       }
161       if (!pdbsSeen.containsKey(pdbFile))
162       {
163         pdbsSeen.put(pdbFile, pdb);
164         pdbSeqs.put(pdb, new ArrayList<SequenceI>());
165       }
166       else
167       {
168         pdb = pdbsSeen.get(pdbFile);
169       }
170       List<SequenceI> seqsForPdb = pdbSeqs.get(pdb);
171       if (!seqsForPdb.contains(seq))
172       {
173         seqsForPdb.add(seq);
174       }
175     }
176
177     /*
178      * convert to Map<PDBEntry, SequenceI[]>
179      */
180     Map<PDBEntry, SequenceI[]> result = new LinkedHashMap<>();
181     for (Entry<PDBEntry, List<SequenceI>> entry : pdbSeqs.entrySet())
182     {
183       List<SequenceI> theSeqs = entry.getValue();
184       result.put(entry.getKey(),
185               theSeqs.toArray(new SequenceI[theSeqs.size()]));
186     }
187
188     return result;
189   }
190
191   /**
192    * A strictly temporary method pending JAL-1761 refactoring. Determines if all
193    * the passed PDB entries are the same (this is the case if selected sequences
194    * to view structure for are chains of the same structure). If so, calls the
195    * single-pdb version of viewStructures and returns the viewer, else returns
196    * null.
197    * 
198    * @param pdbs
199    * @param seqsForPdbs
200    * @param ap
201    * @return
202    */
203   private JalviewStructureDisplayI onlyOnePdb(PDBEntry[] pdbs,
204           SequenceI[] seqsForPdbs, AlignmentPanel ap)
205   {
206     List<SequenceI> seqs = new ArrayList<SequenceI>();
207     if (pdbs == null || pdbs.length == 0)
208     {
209       return null;
210     }
211     int i = 0;
212     String firstFile = pdbs[0].getFile();
213     for (PDBEntry pdb : pdbs)
214     {
215       String pdbFile = pdb.getFile();
216       if (pdbFile == null || !pdbFile.equals(firstFile))
217       {
218         return null;
219       }
220       SequenceI pdbseq = seqsForPdbs[i++];
221       if (pdbseq != null)
222       {
223         seqs.add(pdbseq);
224       }
225     }
226     return viewStructures(pdbs[0], seqs.toArray(new SequenceI[seqs.size()]),
227             ap);
228   }
229
230   public JalviewStructureDisplayI viewStructures(PDBEntry pdb,
231           SequenceI[] seqsForPdb, AlignmentPanel ap)
232   {
233     ViewerType viewerType = getViewerType();
234     JalviewStructureDisplayI sview = null;
235     if (viewerType.equals(ViewerType.JMOL))
236     {
237       sview = new AppJmol(pdb, seqsForPdb, null, ap);
238     }
239     else if (viewerType.equals(ViewerType.CHIMERA))
240     {
241       sview = new ChimeraViewFrame(pdb, seqsForPdb, null, ap);
242     }
243     else
244     {
245       Cache.log.error(UNKNOWN_VIEWER_TYPE + getViewerType().toString());
246     }
247     return sview;
248   }
249
250   /**
251    * Create a new panel controlling a structure viewer.
252    * 
253    * @param type
254    * @param pdbf
255    * @param id
256    * @param sq
257    * @param alignPanel
258    * @param viewerData
259    * @param fileloc
260    * @param rect
261    * @param vid
262    * @return
263    */
264   public JalviewStructureDisplayI createView(ViewerType type, String[] pdbf,
265           String[] id, SequenceI[][] sq, AlignmentPanel alignPanel,
266           StructureViewerModel viewerData, String fileloc, Rectangle rect,
267           String vid)
268   {
269     final boolean useinViewerSuperpos = viewerData.isAlignWithPanel();
270     final boolean usetoColourbyseq = viewerData.isColourWithAlignPanel();
271     final boolean viewerColouring = viewerData.isColourByViewer();
272
273     JalviewStructureDisplayI sview = null;
274     switch (type)
275     {
276     case JMOL:
277       sview = new AppJmol(pdbf, id, sq, alignPanel, usetoColourbyseq,
278               useinViewerSuperpos, viewerColouring, fileloc, rect, vid);
279       break;
280     case CHIMERA:
281       Cache.log.error(
282               "Unsupported structure viewer type " + type.toString());
283       break;
284     default:
285       Cache.log.error(UNKNOWN_VIEWER_TYPE + type.toString());
286     }
287     return sview;
288   }
289
290 }