Bug Summary

File:gromacs/gmxana/gmx_xpm2ps.c
Location:line 768, column 20
Description:The right operand of '/' is a garbage value

Annotated Source Code

1/*
2 * This file is part of the GROMACS molecular simulation package.
3 *
4 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
5 * Copyright (c) 2001-2004, The GROMACS development team.
6 * Copyright (c) 2013,2014, by the GROMACS development team, led by
7 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
8 * and including many others, as listed in the AUTHORS file in the
9 * top-level source directory and at http://www.gromacs.org.
10 *
11 * GROMACS is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public License
13 * as published by the Free Software Foundation; either version 2.1
14 * of the License, or (at your option) any later version.
15 *
16 * GROMACS is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with GROMACS; if not, see
23 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
24 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 *
26 * If you want to redistribute modifications to GROMACS, please
27 * consider that scientific software is very special. Version
28 * control is crucial - bugs must be traceable. We will be happy to
29 * consider code for inclusion in the official distribution, but
30 * derived work must not be called official GROMACS. Details are found
31 * in the README & COPYING files - if they are missing, get the
32 * official version at http://www.gromacs.org.
33 *
34 * To help us fund GROMACS development, we humbly ask that you cite
35 * the research papers on the package. Check out http://www.gromacs.org.
36 */
37#ifdef HAVE_CONFIG_H1
38#include <config.h>
39#endif
40
41#include <stdio.h>
42#include <stdlib.h>
43#include <math.h>
44#include "typedefs.h"
45#include "macros.h"
46#include "gromacs/utility/fatalerror.h"
47#include "gromacs/utility/smalloc.h"
48#include "viewit.h"
49#include "gmx_ana.h"
50
51#include "gromacs/commandline/pargs.h"
52#include "gromacs/utility/futil.h"
53#include "gromacs/fileio/matio.h"
54#include "gromacs/fileio/trxio.h"
55#include "gromacs/fileio/writeps.h"
56
57#define FUDGE1.2 1.2
58#define DDD2 2
59
60typedef struct {
61 real major;
62 real minor;
63 real offset;
64 gmx_bool first;
65 int lineatzero;
66 real majorticklen;
67 real minorticklen;
68 char label[STRLEN4096];
69 real fontsize;
70 char font[STRLEN4096];
71 real tickfontsize;
72 char tickfont[STRLEN4096];
73} t_axisdef;
74
75typedef struct {
76 int bw;
77 real linewidth;
78 real xoffs, yoffs;
79 gmx_bool bTitle;
80 gmx_bool bTitleOnce;
81 gmx_bool bYonce;
82 real titfontsize;
83 char titfont[STRLEN4096];
84 gmx_bool legend;
85 real legfontsize;
86 char legfont[STRLEN4096];
87 char leglabel[STRLEN4096];
88 char leg2label[STRLEN4096];
89 real xboxsize;
90 real yboxsize;
91 real boxspacing;
92 real boxlinewidth;
93 real ticklinewidth;
94 real zerolinewidth;
95 t_axisdef X, Y;
96} t_psrec;
97
98/* MUST correspond to char *legend[] in main() */
99enum {
100 elSel, elBoth, elFirst, elSecond, elNone, elNR
101};
102
103/* MUST correspond to char *combine[] in main() */
104enum {
105 ecSel, ecHalves, ecAdd, ecSub, ecMult, ecDiv, ecNR
106};
107
108void get_params(const char *mpin, const char *mpout, t_psrec *psr)
109{
110 static const char *gmx_bools[BOOL_NR2+1] = { "no", "yes", NULL((void*)0) };
111 /* this must correspond to t_rgb *linecolors[] below */
112 static const char *colors[] = { "none", "black", "white", NULL((void*)0) };
113 warninp_t wi;
114 t_inpfile *inp;
115 const char *tmp;
116 int ninp = 0;
117
118 wi = init_warning(FALSE0, 0);
119
120 if (mpin != NULL((void*)0))
121 {
122 inp = read_inpfile(mpin, &ninp, wi);
123 }
124 else
125 {
126 inp = NULL((void*)0);
127 }
128 ETYPE("black&white", psr->bw, gmx_bools)psr->bw = get_eenum(&ninp, &inp, "black&white"
, gmx_bools);
129 RTYPE("linewidth", psr->linewidth, 1.0)psr->linewidth = get_ereal(&ninp, &inp, "linewidth"
, 1.0, wi);
130 STYPE("titlefont", psr->titfont, "Helvetica")if ((tmp = get_estr(&ninp, &inp, "titlefont", "Helvetica"
)) != ((void*)0)) strcpy(psr->titfont, tmp);
131 RTYPE("titlefontsize", psr->titfontsize, 20.0)psr->titfontsize = get_ereal(&ninp, &inp, "titlefontsize"
, 20.0, wi);
132 ETYPE("legend", psr->legend, gmx_bools)psr->legend = get_eenum(&ninp, &inp, "legend", gmx_bools
);
133 STYPE("legendfont", psr->legfont, psr->titfont)if ((tmp = get_estr(&ninp, &inp, "legendfont", psr->
titfont)) != ((void*)0)) strcpy(psr->legfont, tmp);
134 STYPE("legendlabel", psr->leglabel, "")if ((tmp = get_estr(&ninp, &inp, "legendlabel", "")) !=
((void*)0)) strcpy(psr->leglabel, tmp);
135 STYPE("legend2label", psr->leg2label, psr->leglabel)if ((tmp = get_estr(&ninp, &inp, "legend2label", psr->
leglabel)) != ((void*)0)) strcpy(psr->leg2label, tmp);
136 RTYPE("legendfontsize", psr->legfontsize, 14.0)psr->legfontsize = get_ereal(&ninp, &inp, "legendfontsize"
, 14.0, wi);
137 RTYPE("xbox", psr->xboxsize, 0.0)psr->xboxsize = get_ereal(&ninp, &inp, "xbox", 0.0
, wi);
138 RTYPE("ybox", psr->yboxsize, 0.0)psr->yboxsize = get_ereal(&ninp, &inp, "ybox", 0.0
, wi);
139 RTYPE("matrixspacing", psr->boxspacing, 20.0)psr->boxspacing = get_ereal(&ninp, &inp, "matrixspacing"
, 20.0, wi);
140 RTYPE("xoffset", psr->xoffs, 0.0)psr->xoffs = get_ereal(&ninp, &inp, "xoffset", 0.0
, wi);
141 RTYPE("yoffset", psr->yoffs, psr->xoffs)psr->yoffs = get_ereal(&ninp, &inp, "yoffset", psr
->xoffs, wi);
142 RTYPE("boxlinewidth", psr->boxlinewidth, psr->linewidth)psr->boxlinewidth = get_ereal(&ninp, &inp, "boxlinewidth"
, psr->linewidth, wi);
143 RTYPE("ticklinewidth", psr->ticklinewidth, psr->linewidth)psr->ticklinewidth = get_ereal(&ninp, &inp, "ticklinewidth"
, psr->linewidth, wi);
144 RTYPE("zerolinewidth", psr->zerolinewidth, psr->ticklinewidth)psr->zerolinewidth = get_ereal(&ninp, &inp, "zerolinewidth"
, psr->ticklinewidth, wi);
145 ETYPE("x-lineat0value", psr->X.lineatzero, colors)psr->X.lineatzero = get_eenum(&ninp, &inp, "x-lineat0value"
, colors);
146 RTYPE("x-major", psr->X.major, NOTSET)psr->X.major = get_ereal(&ninp, &inp, "x-major", -
12345, wi);
147 RTYPE("x-minor", psr->X.minor, NOTSET)psr->X.minor = get_ereal(&ninp, &inp, "x-minor", -
12345, wi);
148 RTYPE("x-firstmajor", psr->X.offset, 0.0)psr->X.offset = get_ereal(&ninp, &inp, "x-firstmajor"
, 0.0, wi);
149 ETYPE("x-majorat0", psr->X.first, gmx_bools)psr->X.first = get_eenum(&ninp, &inp, "x-majorat0"
, gmx_bools);
150 RTYPE("x-majorticklen", psr->X.majorticklen, 8.0)psr->X.majorticklen = get_ereal(&ninp, &inp, "x-majorticklen"
, 8.0, wi);
151 RTYPE("x-minorticklen", psr->X.minorticklen, 4.0)psr->X.minorticklen = get_ereal(&ninp, &inp, "x-minorticklen"
, 4.0, wi);
152 STYPE("x-label", psr->X.label, "")if ((tmp = get_estr(&ninp, &inp, "x-label", "")) != (
(void*)0)) strcpy(psr->X.label, tmp);
153 RTYPE("x-fontsize", psr->X.fontsize, 16.0)psr->X.fontsize = get_ereal(&ninp, &inp, "x-fontsize"
, 16.0, wi);
154 STYPE("x-font", psr->X.font, psr->titfont)if ((tmp = get_estr(&ninp, &inp, "x-font", psr->titfont
)) != ((void*)0)) strcpy(psr->X.font, tmp);
155 RTYPE("x-tickfontsize", psr->X.tickfontsize, 10.0)psr->X.tickfontsize = get_ereal(&ninp, &inp, "x-tickfontsize"
, 10.0, wi);
156 STYPE("x-tickfont", psr->X.tickfont, psr->X.font)if ((tmp = get_estr(&ninp, &inp, "x-tickfont", psr->
X.font)) != ((void*)0)) strcpy(psr->X.tickfont, tmp);
157 ETYPE("y-lineat0value", psr->Y.lineatzero, colors)psr->Y.lineatzero = get_eenum(&ninp, &inp, "y-lineat0value"
, colors);
158 RTYPE("y-major", psr->Y.major, psr->X.major)psr->Y.major = get_ereal(&ninp, &inp, "y-major", psr
->X.major, wi);
159 RTYPE("y-minor", psr->Y.minor, psr->X.minor)psr->Y.minor = get_ereal(&ninp, &inp, "y-minor", psr
->X.minor, wi);
160 RTYPE("y-firstmajor", psr->Y.offset, psr->X.offset)psr->Y.offset = get_ereal(&ninp, &inp, "y-firstmajor"
, psr->X.offset, wi);
161 ETYPE("y-majorat0", psr->Y.first, gmx_bools)psr->Y.first = get_eenum(&ninp, &inp, "y-majorat0"
, gmx_bools);
162 RTYPE("y-majorticklen", psr->Y.majorticklen, psr->X.majorticklen)psr->Y.majorticklen = get_ereal(&ninp, &inp, "y-majorticklen"
, psr->X.majorticklen, wi);
163 RTYPE("y-minorticklen", psr->Y.minorticklen, psr->X.minorticklen)psr->Y.minorticklen = get_ereal(&ninp, &inp, "y-minorticklen"
, psr->X.minorticklen, wi);
164 STYPE("y-label", psr->Y.label, psr->X.label)if ((tmp = get_estr(&ninp, &inp, "y-label", psr->X
.label)) != ((void*)0)) strcpy(psr->Y.label, tmp);
165 RTYPE("y-fontsize", psr->Y.fontsize, psr->X.fontsize)psr->Y.fontsize = get_ereal(&ninp, &inp, "y-fontsize"
, psr->X.fontsize, wi);
166 STYPE("y-font", psr->Y.font, psr->X.font)if ((tmp = get_estr(&ninp, &inp, "y-font", psr->X.
font)) != ((void*)0)) strcpy(psr->Y.font, tmp);
167 RTYPE("y-tickfontsize", psr->Y.tickfontsize, psr->X.tickfontsize)psr->Y.tickfontsize = get_ereal(&ninp, &inp, "y-tickfontsize"
, psr->X.tickfontsize, wi);
168 STYPE("y-tickfont", psr->Y.tickfont, psr->Y.font)if ((tmp = get_estr(&ninp, &inp, "y-tickfont", psr->
Y.font)) != ((void*)0)) strcpy(psr->Y.tickfont, tmp);
169
170 if (mpout != NULL((void*)0))
171 {
172 write_inpfile(mpout, ninp, inp, TRUE1, wi);
173 }
174
175 done_warning(wi, FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 175);
176}
177
178t_rgb black = { 0, 0, 0 };
179t_rgb white = { 1, 1, 1 };
180t_rgb red = { 1, 0, 0 };
181t_rgb blue = { 0, 0, 1 };
182#define BLACK(&black) (&black)
183/* this must correspond to *colors[] in get_params */
184t_rgb *linecolors[] = { NULL((void*)0), &black, &white, NULL((void*)0) };
185
186gmx_bool diff_maps(int nmap1, t_mapping *map1, int nmap2, t_mapping *map2)
187{
188 int i;
189 gmx_bool bDiff, bColDiff = FALSE0;
190
191 if (nmap1 != nmap2)
192 {
193 bDiff = TRUE1;
194 }
195 else
196 {
197 bDiff = FALSE0;
198 for (i = 0; i < nmap1; i++)
199 {
200 if (!matelmt_cmp(map1[i].code, map2[i].code))
201 {
202 bDiff = TRUE1;
203 }
204 if (strcmp(map1[i].desc, map2[i].desc)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(map1[i].desc) && __builtin_constant_p (map2[i].desc
) && (__s1_len = strlen (map1[i].desc), __s2_len = strlen
(map2[i].desc), (!((size_t)(const void *)((map1[i].desc) + 1
) - (size_t)(const void *)(map1[i].desc) == 1) || __s1_len >=
4) && (!((size_t)(const void *)((map2[i].desc) + 1) -
(size_t)(const void *)(map2[i].desc) == 1) || __s2_len >=
4)) ? __builtin_strcmp (map1[i].desc, map2[i].desc) : (__builtin_constant_p
(map1[i].desc) && ((size_t)(const void *)((map1[i].desc
) + 1) - (size_t)(const void *)(map1[i].desc) == 1) &&
(__s1_len = strlen (map1[i].desc), __s1_len < 4) ? (__builtin_constant_p
(map2[i].desc) && ((size_t)(const void *)((map2[i].desc
) + 1) - (size_t)(const void *)(map2[i].desc) == 1) ? __builtin_strcmp
(map1[i].desc, map2[i].desc) : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (map2[i]
.desc); int __result = (((const unsigned char *) (const char *
) (map1[i].desc))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (map1[i].desc))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (map1[i].desc))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (map1[i].desc))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(map2[i].desc) && ((size_t)(const void *)((map2[i].desc
) + 1) - (size_t)(const void *)(map2[i].desc) == 1) &&
(__s2_len = strlen (map2[i].desc), __s2_len < 4) ? (__builtin_constant_p
(map1[i].desc) && ((size_t)(const void *)((map1[i].desc
) + 1) - (size_t)(const void *)(map1[i].desc) == 1) ? __builtin_strcmp
(map1[i].desc, map2[i].desc) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (map1[i]
.desc); int __result = (((const unsigned char *) (const char *
) (map2[i].desc))[0] - __s2[0]); if (__s2_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (map2[i].desc))[1] - __s2[1]); if (__s2_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (map2[i].desc))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (map2[i].desc))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(map1[i].desc, map2[i].desc)))); }) != 0)
205 {
206 bDiff = TRUE1;
207 }
208 if ((map1[i].rgb.r != map2[i].rgb.r) ||
209 (map1[i].rgb.g != map2[i].rgb.g) ||
210 (map1[i].rgb.b != map2[i].rgb.b))
211 {
212 bColDiff = TRUE1;
213 }
214 }
215 if (!bDiff && bColDiff)
216 {
217 fprintf(stderrstderr, "Warning: two colormaps differ only in RGB value, using one colormap.\n");
218 }
219 }
220
221 return bDiff;
222}
223
224void leg_discrete(t_psdata ps, real x0, real y0, char *label,
225 real fontsize, char *font, int nmap, t_mapping map[])
226{
227 int i;
228 real yhh;
229 real boxhh;
230
231 boxhh = fontsize+DDD2;
232 /* LANDSCAPE */
233 ps_rgb(ps, BLACK(&black));
234 ps_strfont(ps, font, fontsize);
235 yhh = y0+fontsize+3*DDD2;
236 if ((int)strlen(label) > 0)
237 {
238 ps_ctext(ps, x0, yhh, label, eXLeft);
239 }
240 ps_moveto(ps, x0, y0);
241 for (i = 0; (i < nmap); i++)
242 {
243 ps_setorigin(ps);
244 ps_rgb(ps, &(map[i].rgb));
245 ps_fillbox(ps, DDD2, DDD2, DDD2+fontsize, boxhh-DDD2);
246 ps_rgb(ps, BLACK(&black));
247 ps_box(ps, DDD2, DDD2, DDD2+fontsize, boxhh-DDD2);
248 ps_ctext(ps, boxhh+2*DDD2, fontsize/3, map[i].desc, eXLeft);
249 ps_unsetorigin(ps);
250 ps_moverel(ps, DDD2, -fontsize/3);
251 }
252}
253
254void leg_continuous(t_psdata ps, real x0, real x, real y0, char *label,
255 real fontsize, char *font,
256 int nmap, t_mapping map[],
257 int mapoffset)
258{
259 int i;
260 real xx0;
261 real yhh, boxxh, boxyh;
262
263 boxyh = fontsize;
264 if (x < 8*fontsize)
265 {
266 x = 8*fontsize;
267 }
268 boxxh = (real)x/(real)(nmap-mapoffset);
269 if (boxxh > fontsize)
270 {
271 boxxh = fontsize;
272 }
273
274 /* LANDSCAPE */
275 xx0 = x0-((nmap-mapoffset)*boxxh)/2.0;
276
277 for (i = 0; (i < nmap-mapoffset); i++)
278 {
279 ps_rgb(ps, &(map[i+mapoffset].rgb));
280 ps_fillbox(ps, xx0+i*boxxh, y0, xx0+(i+1)*boxxh, y0+boxyh);
281 }
282 ps_strfont(ps, font, fontsize);
283 ps_rgb(ps, BLACK(&black));
284 ps_box(ps, xx0, y0, xx0+(nmap-mapoffset)*boxxh, y0+boxyh);
285
286 yhh = y0+boxyh+3*DDD2;
287 ps_ctext(ps, xx0+boxxh/2, yhh, map[0].desc, eXCenter);
288 if ((int)strlen(label) > 0)
289 {
290 ps_ctext(ps, x0, yhh, label, eXCenter);
291 }
292 ps_ctext(ps, xx0+((nmap-mapoffset)*boxxh)
293 - boxxh/2, yhh, map[nmap-1].desc, eXCenter);
294}
295
296void leg_bicontinuous(t_psdata ps, real x0, real x, real y0, char *label1,
297 char *label2, real fontsize, char *font,
298 int nmap1, t_mapping map1[], int nmap2, t_mapping map2[])
299{
300 real xx1, xx2, x1, x2;
301
302 x1 = x/(nmap1+nmap2)*nmap1; /* width of legend 1 */
303 x2 = x/(nmap1+nmap2)*nmap2; /* width of legend 2 */
304 xx1 = x0-(x2/2.0)-fontsize; /* center of legend 1 */
305 xx2 = x0+(x1/2.0)+fontsize; /* center of legend 2 */
306 x1 -= fontsize/2; /* adjust width */
307 x2 -= fontsize/2; /* adjust width */
308 leg_continuous(ps, xx1, x1, y0, label1, fontsize, font, nmap1, map1, 0);
309 leg_continuous(ps, xx2, x2, y0, label2, fontsize, font, nmap2, map2, 0);
310}
311
312static real box_height(t_matrix *mat, t_psrec *psr)
313{
314 return mat->ny*psr->yboxsize;
315}
316
317static real box_dh(t_psrec *psr)
318{
319 return psr->boxspacing;
320}
321
322#define IS_ONCE(i == nmat-1) (i == nmat-1)
323static real box_dh_top(gmx_bool bOnce, t_psrec *psr)
324{
325 real dh;
326
327 if (psr->bTitle || (psr->bTitleOnce && bOnce) )
328 {
329 dh = 2*psr->titfontsize;
330 }
331 else
332 {
333 dh = 0;
334 }
335
336 return dh;
337}
338
339static gmx_bool box_do_all_x_maj_ticks(t_psrec *psr)
340{
341 return (psr->boxspacing > (1.5*psr->X.majorticklen));
342}
343
344static gmx_bool box_do_all_x_min_ticks(t_psrec *psr)
345{
346 return (psr->boxspacing > (1.5*psr->X.minorticklen));
347}
348
349static void draw_boxes(t_psdata ps, real x0, real y0, real w,
350 int nmat, t_matrix mat[], t_psrec *psr)
351{
352 char buf[128];
353 char *mylab;
354 real xxx;
355 char **xtick, **ytick;
356 real xx, yy, dy, xx00, yy00, offset_x, offset_y;
357 int i, j, x, y, ntx, nty, strlength;
358
359 /* Only necessary when there will be no y-labels */
360 strlength = 0;
361
362 /* Draw the box */
363 ps_rgb(ps, BLACK(&black));
364 ps_linewidth(ps, psr->boxlinewidth);
365 yy00 = y0;
366 for (i = 0; (i < nmat); i++)
367 {
368 dy = box_height(&(mat[i]), psr);
369 ps_box(ps, x0-1, yy00-1, x0+w+1, yy00+dy+1);
370 yy00 += dy+box_dh(psr)+box_dh_top(IS_ONCE(i == nmat-1), psr);
371 }
372
373 /* Draw the ticks on the axes */
374 ps_linewidth(ps, psr->ticklinewidth);
375 xx00 = x0-1;
376 yy00 = y0-1;
377 for (i = 0; (i < nmat); i++)
378 {
379 if (mat[i].flags & MAT_SPATIAL_X(1<<0))
380 {
381 ntx = mat[i].nx + 1;
382 offset_x = 0.1;
383 }
384 else
385 {
386 ntx = mat[i].nx;
387 offset_x = 0.6;
388 }
389 if (mat[i].flags & MAT_SPATIAL_Y(1<<1))
390 {
391 nty = mat[i].ny + 1;
392 offset_y = 0.1;
393 }
394 else
395 {
396 nty = mat[i].ny;
397 offset_y = 0.6;
398 }
399 snew(xtick, ntx)(xtick) = save_calloc("xtick", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 399, (ntx), sizeof(*(xtick)));
400 for (j = 0; (j < ntx); j++)
401 {
402 sprintf(buf, "%g", mat[i].axis_x[j]);
403 xtick[j] = strdup(buf)(__extension__ (__builtin_constant_p (buf) && ((size_t
)(const void *)((buf) + 1) - (size_t)(const void *)(buf) == 1
) ? (((const char *) (buf))[0] == '\0' ? (char *) calloc ((size_t
) 1, (size_t) 1) : ({ size_t __len = strlen (buf) + 1; char *
__retval = (char *) malloc (__len); if (__retval != ((void*)0
)) __retval = (char *) memcpy (__retval, buf, __len); __retval
; })) : __strdup (buf)));
404 }
405 ps_strfont(ps, psr->X.tickfont, psr->X.tickfontsize);
406 for (x = 0; (x < ntx); x++)
407 {
408 xx = xx00 + (x + offset_x)*psr->xboxsize;
409 if ( ( bRmod(mat[i].axis_x[x], psr->X.offset, psr->X.major)bRmod_fd(mat[i].axis_x[x], psr->X.offset, psr->X.major,
0) ||
410 (psr->X.first && (x == 0))) &&
411 ( (i == 0) || box_do_all_x_maj_ticks(psr) ) )
412 {
413 /* Longer tick marks */
414 ps_line (ps, xx, yy00, xx, yy00-psr->X.majorticklen);
415 /* Plot label on lowest graph only */
416 if (i == 0)
417 {
418 ps_ctext(ps, xx,
419 yy00-DDD2-psr->X.majorticklen-psr->X.tickfontsize*0.8,
420 xtick[x], eXCenter);
421 }
422 }
423 else if (bRmod(mat[i].axis_x[x], psr->X.offset, psr->X.minor)bRmod_fd(mat[i].axis_x[x], psr->X.offset, psr->X.minor,
0) &&
424 ( (i == 0) || box_do_all_x_min_ticks(psr) ) )
425 {
426 /* Shorter tick marks */
427 ps_line(ps, xx, yy00, xx, yy00-psr->X.minorticklen);
428 }
429 else if (bRmod(mat[i].axis_x[x], psr->X.offset, psr->X.major)bRmod_fd(mat[i].axis_x[x], psr->X.offset, psr->X.major,
0) )
430 {
431 /* Even shorter marks, only each X.major */
432 ps_line(ps, xx, yy00, xx, yy00-(psr->boxspacing/2));
433 }
434 }
435 ps_strfont(ps, psr->Y.tickfont, psr->Y.tickfontsize);
436 snew(ytick, nty)(ytick) = save_calloc("ytick", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 436, (nty), sizeof(*(ytick)));
437 for (j = 0; (j < nty); j++)
438 {
439 sprintf(buf, "%g", mat[i].axis_y[j]);
440 ytick[j] = strdup(buf)(__extension__ (__builtin_constant_p (buf) && ((size_t
)(const void *)((buf) + 1) - (size_t)(const void *)(buf) == 1
) ? (((const char *) (buf))[0] == '\0' ? (char *) calloc ((size_t
) 1, (size_t) 1) : ({ size_t __len = strlen (buf) + 1; char *
__retval = (char *) malloc (__len); if (__retval != ((void*)0
)) __retval = (char *) memcpy (__retval, buf, __len); __retval
; })) : __strdup (buf)));
441 }
442
443 for (y = 0; (y < nty); y++)
444 {
445 yy = yy00 + (y + offset_y)*psr->yboxsize;
446 if (bRmod(mat[i].axis_y[y], psr->Y.offset, psr->Y.major)bRmod_fd(mat[i].axis_y[y], psr->Y.offset, psr->Y.major,
0) ||
447 (psr->Y.first && (y == 0)))
448 {
449 /* Major ticks */
450 strlength = max(strlength, (int)strlen(ytick[y]))(((strlength) > ((int)strlen(ytick[y]))) ? (strlength) : (
(int)strlen(ytick[y])) );
451 ps_line (ps, xx00, yy, xx00-psr->Y.majorticklen, yy);
452 ps_ctext(ps, xx00-psr->Y.majorticklen-DDD2,
453 yy-psr->Y.tickfontsize/3.0, ytick[y], eXRight);
454 }
455 else if (bRmod(mat[i].axis_y[y], psr->Y.offset, psr->Y.minor)bRmod_fd(mat[i].axis_y[y], psr->Y.offset, psr->Y.minor,
0) )
456 {
457 /* Minor ticks */
458 ps_line(ps, xx00, yy, xx00-psr->Y.minorticklen, yy);
459 }
460 }
461 sfree(xtick)save_free("xtick", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 461, (xtick));
462 sfree(ytick)save_free("ytick", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 462, (ytick));
463
464 /* Label on Y-axis */
465 if (!psr->bYonce || i == nmat/2)
466 {
467 if (strlen(psr->Y.label) > 0)
468 {
469 mylab = psr->Y.label;
470 }
471 else
472 {
473 mylab = mat[i].label_y;
474 }
475 if (strlen(mylab) > 0)
476 {
477 ps_strfont(ps, psr->Y.font, psr->Y.fontsize);
478 ps_flip(ps, TRUE1);
479 xxx = x0-psr->X.majorticklen-psr->X.tickfontsize*strlength-DDD2;
480 ps_ctext(ps, yy00+box_height(&mat[i], psr)/2.0, 612.5-xxx,
481 mylab, eXCenter);
482 ps_flip(ps, FALSE0);
483 }
484 }
485
486 yy00 += box_height(&(mat[i]), psr)+box_dh(psr)+box_dh_top(IS_ONCE(i == nmat-1), psr);
487 }
488 /* Label on X-axis */
489 if (strlen(psr->X.label) > 0)
490 {
491 mylab = psr->X.label;
492 }
493 else
494 {
495 mylab = mat[0].label_x;
496 }
497 if (strlen(mylab) > 0)
498 {
499 ps_strfont(ps, psr->X.font, psr->X.fontsize);
500 ps_ctext(ps, x0+w/2, y0-DDD2-psr->X.majorticklen-psr->X.tickfontsize*FUDGE1.2-
501 psr->X.fontsize, mylab, eXCenter);
502 }
503}
504
505static void draw_zerolines(t_psdata out, real x0, real y0, real w,
506 int nmat, t_matrix mat[], t_psrec *psr)
507{
508 real xx, yy, dy, xx00, yy00;
509 int i, x, y;
510
511 xx00 = x0-1.5;
512 yy00 = y0-1.5;
513 ps_linewidth(out, psr->zerolinewidth);
514 for (i = 0; (i < nmat); i++)
515 {
516 dy = box_height(&(mat[i]), psr);
517 /* mat[i].axis_x and _y were already set by draw_boxes */
518 if (psr->X.lineatzero)
519 {
520 ps_rgb(out, linecolors[psr->X.lineatzero]);
521 for (x = 0; (x < mat[i].nx); x++)
522 {
523 xx = xx00+(x+0.7)*psr->xboxsize;
524 /* draw lines whenever tick label almost zero (e.g. next trajectory) */
525 if (x != 0 && x < mat[i].nx-1 &&
526 abs(mat[i].axis_x[x]) <
527 0.1*abs(mat[i].axis_x[x+1]-mat[i].axis_x[x]) )
528 {
529 ps_line (out, xx, yy00, xx, yy00+dy+2);
530 }
531 }
532 }
533 if (psr->Y.lineatzero)
534 {
535 ps_rgb(out, linecolors[psr->Y.lineatzero]);
536 for (y = 0; (y < mat[i].ny); y++)
537 {
538 yy = yy00+(y+0.7)*psr->yboxsize;
539 /* draw lines whenever tick label almost zero (e.g. next trajectory) */
540 if (y != 0 && y < mat[i].ny-1 &&
541 abs(mat[i].axis_y[y]) <
542 0.1*abs(mat[i].axis_y[y+1]-mat[i].axis_y[y]) )
543 {
544 ps_line (out, xx00, yy, xx00+w+2, yy);
545 }
546 }
547 }
548 yy00 += box_height(&(mat[i]), psr)+box_dh(psr)+box_dh_top(IS_ONCE(i == nmat-1), psr);
549 }
550}
551
552static void box_dim(int nmat, t_matrix mat[], t_matrix *mat2, t_psrec *psr,
553 int elegend, gmx_bool bFrame,
554 real *w, real *h, real *dw, real *dh)
555{
556 int i, maxytick;
557 real ww, hh, dww, dhh;
558
559 hh = dww = dhh = 0;
560 maxytick = 0;
561
562 ww = 0;
563 for (i = 0; (i < nmat); i++)
564 {
565 ww = max(ww, mat[i].nx*psr->xboxsize)(((ww) > (mat[i].nx*psr->xboxsize)) ? (ww) : (mat[i].nx
*psr->xboxsize) );
566 hh += box_height(&(mat[i]), psr);
567 maxytick = max(maxytick, mat[i].nx)(((maxytick) > (mat[i].nx)) ? (maxytick) : (mat[i].nx) );
568 }
569 if (bFrame)
570 {
571 if (mat[0].label_y[0])
572 {
573 dww += 2.0*(psr->Y.fontsize+DDD2);
574 }
575 if (psr->Y.major > 0)
576 {
577 dww += psr->Y.majorticklen + DDD2 +
578 psr->Y.tickfontsize*(log(maxytick)/log(10.0));
579 }
580 else if (psr->Y.minor > 0)
581 {
582 dww += psr->Y.minorticklen;
583 }
584
585 if (mat[0].label_x[0])
586 {
587 dhh += psr->X.fontsize+2*DDD2;
588 }
589 if ( /* fool emacs auto-indent */
590 (elegend == elBoth && (mat[0].legend[0] || mat2[0].legend[0])) ||
591 (elegend == elFirst && mat[0].legend[0]) ||
592 (elegend == elSecond && mat2[0].legend[0]) )
593 {
594 dhh += 2*(psr->legfontsize*FUDGE1.2+2*DDD2);
595 }
596 else
597 {
598 dhh += psr->legfontsize*FUDGE1.2+2*DDD2;
599 }
600 if (psr->X.major > 0)
601 {
602 dhh += psr->X.tickfontsize*FUDGE1.2+2*DDD2+psr->X.majorticklen;
603 }
604 else if (psr->X.minor > 0)
605 {
606 dhh += psr->X.minorticklen;
607 }
608
609 hh += (nmat-1)*box_dh(psr);
610 hh += box_dh_top(TRUE1, psr);
611 if (nmat > 1)
612 {
613 hh += (nmat-1)*box_dh_top(FALSE0, psr);
614 }
615 }
616 *w = ww;
617 *h = hh;
618 *dw = dww;
619 *dh = dhh;
620}
621
622int add_maps(t_mapping **newmap,
623 int nmap1, t_mapping map1[], int nmap2, t_mapping map2[])
624{
625 static char mapper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_=+{}|;:',<.>/?";
626 int nsymbols;
627 int nmap, j, k;
628 t_mapping *map;
629
630 nsymbols = strlen(mapper);
631 nmap = nmap1+nmap2;
632 if (nmap > nsymbols*nsymbols)
633 {
634 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 634, "Not enough symbols to merge the two colormaps\n");
635 }
636 printf("Combining colormaps of %d and %d elements into one of %d elements\n",
637 nmap1, nmap2, nmap);
638 snew(map, nmap)(map) = save_calloc("map", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 638, (nmap), sizeof(*(map)));
639 for (j = 0; j < nmap1; j++)
640 {
641 map[j].code.c1 = mapper[j % nsymbols];
642 if (nmap > nsymbols)
643 {
644 map[j].code.c2 = mapper[j/nsymbols];
645 }
646 map[j].rgb.r = map1[j].rgb.r;
647 map[j].rgb.g = map1[j].rgb.g;
648 map[j].rgb.b = map1[j].rgb.b;
649 map[j].desc = map1[j].desc;
650 }
651 for (j = 0; j < nmap2; j++)
652 {
653 k = j+nmap1;
654 map[k].code.c1 = mapper[k % nsymbols];
655 if (nmap > nsymbols)
656 {
657 map[k].code.c2 = mapper[k/nsymbols];
658 }
659 map[k].rgb.r = map2[j].rgb.r;
660 map[k].rgb.g = map2[j].rgb.g;
661 map[k].rgb.b = map2[j].rgb.b;
662 map[k].desc = map2[j].desc;
663 }
664
665 *newmap = map;
666 return nmap;
667}
668
669void xpm_mat(const char *outf, int nmat, t_matrix *mat, t_matrix *mat2,
670 gmx_bool bDiag, gmx_bool bFirstDiag)
671{
672 FILE *out;
673 char buf[100];
674 int i, j, k, x, y, col;
675 int nmap;
676 t_mapping *map = NULL((void*)0);
677
678 out = gmx_ffopen(outf, "w");
679
680 for (i = 0; i < nmat; i++)
681 {
682 if (!mat2 || !diff_maps(mat[i].nmap, mat[i].map, mat2[i].nmap, mat2[i].map))
683 {
684 write_xpm_m(out, mat[0]);
685 }
686 else
687 {
688 nmap = add_maps(&map, mat[i].nmap, mat[i].map, mat2[i].nmap, mat2[i].map);
689 for (x = 0; (x < mat[i].nx); x++)
690 {
691 for (y = 0; (y < mat[i].nx); y++)
692 {
693 if ((x < y) || ((x == y) && bFirstDiag)) /* upper left -> map1 */
694 {
695 col = mat[i].matrix[x][y];
696 }
697 else /* lower right -> map2 */
698 {
699 col = mat[i].nmap+mat[i].matrix[x][y];
700 }
701 if ((bDiag) || (x != y))
702 {
703 mat[i].matrix[x][y] = col;
704 }
705 else
706 {
707 mat[i].matrix[x][y] = 0;
708 }
709 }
710 }
711 sfree(mat[i].map)save_free("mat[i].map", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 711, (mat[i].map));
712 mat[i].nmap = nmap;
713 mat[i].map = map;
714 if (mat2 && (strcmp(mat[i].title, mat2[i].title)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(mat[i].title) && __builtin_constant_p (mat2[i].title
) && (__s1_len = strlen (mat[i].title), __s2_len = strlen
(mat2[i].title), (!((size_t)(const void *)((mat[i].title) + 1
) - (size_t)(const void *)(mat[i].title) == 1) || __s1_len >=
4) && (!((size_t)(const void *)((mat2[i].title) + 1)
- (size_t)(const void *)(mat2[i].title) == 1) || __s2_len >=
4)) ? __builtin_strcmp (mat[i].title, mat2[i].title) : (__builtin_constant_p
(mat[i].title) && ((size_t)(const void *)((mat[i].title
) + 1) - (size_t)(const void *)(mat[i].title) == 1) &&
(__s1_len = strlen (mat[i].title), __s1_len < 4) ? (__builtin_constant_p
(mat2[i].title) && ((size_t)(const void *)((mat2[i].
title) + 1) - (size_t)(const void *)(mat2[i].title) == 1) ? __builtin_strcmp
(mat[i].title, mat2[i].title) : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (mat2[i]
.title); int __result = (((const unsigned char *) (const char
*) (mat[i].title))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat[i].title))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat[i].title))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (mat[i].title))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(mat2[i].title) && ((size_t)(const void *)((mat2[i].
title) + 1) - (size_t)(const void *)(mat2[i].title) == 1) &&
(__s2_len = strlen (mat2[i].title), __s2_len < 4) ? (__builtin_constant_p
(mat[i].title) && ((size_t)(const void *)((mat[i].title
) + 1) - (size_t)(const void *)(mat[i].title) == 1) ? __builtin_strcmp
(mat[i].title, mat2[i].title) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (mat[i].
title); int __result = (((const unsigned char *) (const char *
) (mat2[i].title))[0] - __s2[0]); if (__s2_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat2[i].title))[1] - __s2[1]); if (__s2_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat2[i].title))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (mat2[i].title))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(mat[i].title, mat2[i].title)))); }) != 0))
715 {
716 sprintf(mat[i].title+strlen(mat[i].title), " / %s", mat2[i].title);
717 }
718 if (mat2 && (strcmp(mat[i].legend, mat2[i].legend)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(mat[i].legend) && __builtin_constant_p (mat2[i].legend
) && (__s1_len = strlen (mat[i].legend), __s2_len = strlen
(mat2[i].legend), (!((size_t)(const void *)((mat[i].legend) +
1) - (size_t)(const void *)(mat[i].legend) == 1) || __s1_len
>= 4) && (!((size_t)(const void *)((mat2[i].legend
) + 1) - (size_t)(const void *)(mat2[i].legend) == 1) || __s2_len
>= 4)) ? __builtin_strcmp (mat[i].legend, mat2[i].legend)
: (__builtin_constant_p (mat[i].legend) && ((size_t)
(const void *)((mat[i].legend) + 1) - (size_t)(const void *)(
mat[i].legend) == 1) && (__s1_len = strlen (mat[i].legend
), __s1_len < 4) ? (__builtin_constant_p (mat2[i].legend) &&
((size_t)(const void *)((mat2[i].legend) + 1) - (size_t)(const
void *)(mat2[i].legend) == 1) ? __builtin_strcmp (mat[i].legend
, mat2[i].legend) : (__extension__ ({ const unsigned char *__s2
= (const unsigned char *) (const char *) (mat2[i].legend); int
__result = (((const unsigned char *) (const char *) (mat[i].
legend))[0] - __s2[0]); if (__s1_len > 0 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
mat[i].legend))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat[i].legend))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (mat[i].legend))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(mat2[i].legend) && ((size_t)(const void *)((mat2[i]
.legend) + 1) - (size_t)(const void *)(mat2[i].legend) == 1) &&
(__s2_len = strlen (mat2[i].legend), __s2_len < 4) ? (__builtin_constant_p
(mat[i].legend) && ((size_t)(const void *)((mat[i].legend
) + 1) - (size_t)(const void *)(mat[i].legend) == 1) ? __builtin_strcmp
(mat[i].legend, mat2[i].legend) : (- (__extension__ ({ const
unsigned char *__s2 = (const unsigned char *) (const char *)
(mat[i].legend); int __result = (((const unsigned char *) (const
char *) (mat2[i].legend))[0] - __s2[0]); if (__s2_len > 0
&& __result == 0) { __result = (((const unsigned char
*) (const char *) (mat2[i].legend))[1] - __s2[1]); if (__s2_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) (mat2[i].legend))[2] - __s2[2]); if (
__s2_len > 2 && __result == 0) __result = (((const
unsigned char *) (const char *) (mat2[i].legend))[3] - __s2[
3]); } } __result; })))) : __builtin_strcmp (mat[i].legend, mat2
[i].legend)))); }) != 0))
719 {
720 sprintf(mat[i].legend+strlen(mat[i].legend), " / %s", mat2[i].legend);
721 }
722 write_xpm_m(out, mat[i]);
723 }
724 }
725 gmx_ffclose(out);
726}
727
728static void tick_spacing(int n, real axis[], real offset, char axisnm,
729 real *major, real *minor)
730{
731 real space;
732 gmx_bool bTryAgain, bFive;
733 int i, j, t, f = 0, ten;
734#define NFACT4 4
735 real major_fact[NFACT4] = {5, 4, 2, 1};
736 real minor_fact[NFACT4] = {5, 4, 4, 5};
737
738 /* start with interval between 10 matrix points: */
739 space = max(10*axis[1]-axis[0], axis[min(10, n-1)]-axis[0])(((10*axis[1]-axis[0]) > (axis[(((10) < (n-1)) ? (10) :
(n-1) )]-axis[0])) ? (10*axis[1]-axis[0]) : (axis[(((10) <
(n-1)) ? (10) : (n-1) )]-axis[0]) );
740 /* get power of 10 */
741 ten = (int)ceil(log(space)/log(10))-1;
742 bTryAgain = TRUE1;
743 for (t = ten+2; t > ten-3 && bTryAgain; t--)
744 {
745 for (f = 0; f < NFACT4 && bTryAgain; f++)
746 {
747 space = pow(10, t) * major_fact[f];
748 /* count how many ticks we would get: */
749 i = 0;
750 for (j = 0; j < n; j++)
751 {
752 if (bRmod(axis[j], offset, space)bRmod_fd(axis[j], offset, space, 0) )
753 {
754 i++;
755 }
756 }
757 /* do we have a reasonable number of ticks ? */
758 bTryAgain = (i > min(10, n-1)(((10) < (n-1)) ? (10) : (n-1) )) || (i < 5);
759 }
760 }
761 if (bTryAgain)
1
Taking true branch
→
762 {
763 space = max(10*axis[1]-axis[0], axis[min(10, n-1)]-axis[0])(((10*axis[1]-axis[0]) > (axis[(((10) < (n-1)) ? (10) :
(n-1) )]-axis[0])) ? (10*axis[1]-axis[0]) : (axis[(((10) <
(n-1)) ? (10) : (n-1) )]-axis[0]) );
764 fprintf(stderrstderr, "Auto tick spacing failed for %c-axis, guessing %g\n",
765 axisnm, space);
766 }
767 *major = space;
768 *minor = space / minor_fact[f-1];
2
←
The right operand of '/' is a garbage value
769 fprintf(stderrstderr, "Auto tick spacing for %c-axis: major %g, minor %g\n",
770 axisnm, *major, *minor);
771}
772
773void ps_mat(const char *outf, int nmat, t_matrix mat[], t_matrix mat2[],
774 gmx_bool bFrame, gmx_bool bDiag, gmx_bool bFirstDiag,
775 gmx_bool bTitle, gmx_bool bTitleOnce, gmx_bool bYonce, int elegend,
776 real size, real boxx, real boxy, const char *m2p, const char *m2pout,
777 int mapoffset)
778{
779 const char *libm2p;
780 char buf[256], *legend;
781 t_psdata out;
782 t_psrec psrec, *psr;
783 int W, H;
784 int i, j, x, y, col, leg = 0;
785 real x0, y0, xx;
786 real w, h, dw, dh;
787 int nmap1 = 0, nmap2 = 0, leg_nmap;
788 t_mapping *map1 = NULL((void*)0), *map2 = NULL((void*)0), *leg_map;
789 gmx_bool bMap1, bNextMap1, bDiscrete;
790
791 /* memory leak: */
792 libm2p = m2p ? gmxlibfn(m2p) : m2p;
793 get_params(libm2p, m2pout, &psrec);
794
795 psr = &psrec;
796
797 if (psr->X.major <= 0)
798 {
799 tick_spacing((mat[0].flags & MAT_SPATIAL_X(1<<0)) ? mat[0].nx + 1 : mat[0].nx,
800 mat[0].axis_x, psr->X.offset, 'X',
801 &(psr->X.major), &(psr->X.minor) );
802 }
803 if (psr->X.minor <= 0)
804 {
805 psr->X.minor = psr->X.major / 2;
806 }
807 if (psr->Y.major <= 0)
808 {
809 tick_spacing((mat[0].flags & MAT_SPATIAL_Y(1<<1)) ? mat[0].ny + 1 : mat[0].ny,
810 mat[0].axis_y, psr->Y.offset, 'Y',
811 &(psr->Y.major), &(psr->Y.minor) );
812 }
813 if (psr->Y.minor <= 0)
814 {
815 psr->Y.minor = psr->Y.major / 2;
816 }
817
818 if (boxx > 0)
819 {
820 psr->xboxsize = boxx;
821 psr->yboxsize = boxx;
822 }
823 if (boxy > 0)
824 {
825 psr->yboxsize = boxy;
826 }
827
828 if (psr->xboxsize == 0)
829 {
830 psr->xboxsize = size/mat[0].nx;
831 printf("Set the x-size of the box to %.3f\n", psr->xboxsize);
832 }
833 if (psr->yboxsize == 0)
834 {
835 psr->yboxsize = size/mat[0].nx;
836 printf("Set the y-size of the box to %.3f\n", psr->yboxsize);
837 }
838
839 nmap1 = 0;
840 for (i = 0; (i < nmat); i++)
841 {
842 if (mat[i].nmap > nmap1)
843 {
844 nmap1 = mat[i].nmap;
845 map1 = mat[i].map;
846 leg = i+1;
847 }
848 }
849 if (leg != 1)
850 {
851 printf("Selected legend of matrix # %d for display\n", leg);
852 }
853 if (mat2)
854 {
855 nmap2 = 0;
856 for (i = 0; (i < nmat); i++)
857 {
858 if (mat2[i].nmap > nmap2)
859 {
860 nmap2 = mat2[i].nmap;
861 map2 = mat2[i].map;
862 leg = i+1;
863 }
864 }
865 if (leg != 1)
866 {
867 printf("Selected legend of matrix # %d for second display\n", leg);
868 }
869 }
870 if ( (mat[0].legend[0] == 0) && psr->legend)
871 {
872 strcpy(mat[0].legend, psr->leglabel);
873 }
874
875 bTitle = bTitle && mat[nmat-1].title[0];
876 bTitleOnce = bTitleOnce && mat[nmat-1].title[0];
877 psr->bTitle = bTitle;
878 psr->bTitleOnce = bTitleOnce;
879 psr->bYonce = bYonce;
880
881 /* Set up size of box for nice colors */
882 box_dim(nmat, mat, mat2, psr, elegend, bFrame, &w, &h, &dw, &dh);
883
884 /* Set up bounding box */
885 W = w+dw;
886 H = h+dh;
887
888 /* Start box at */
889 x0 = dw;
890 y0 = dh;
891 x = W+psr->xoffs;
892 y = H+psr->yoffs;
893 if (bFrame)
894 {
895 x += 5*DDD2;
896 y += 4*DDD2;
897 }
898 out = ps_open(outf, 0, 0, x, y);
899 ps_linewidth(out, psr->linewidth);
900 ps_init_rgb_box(out, psr->xboxsize, psr->yboxsize);
901 ps_init_rgb_nbox(out, psr->xboxsize, psr->yboxsize);
902 ps_translate(out, psr->xoffs, psr->yoffs);
903
904 if (bFrame)
905 {
906 ps_comment(out, "Here starts the BOX drawing");
907 draw_boxes(out, x0, y0, w, nmat, mat, psr);
908 }
909
910 for (i = 0; (i < nmat); i++)
911 {
912 if (bTitle || (bTitleOnce && i == nmat-1) )
913 {
914 /* Print title, if any */
915 ps_rgb(out, BLACK(&black));
916 ps_strfont(out, psr->titfont, psr->titfontsize);
917 if (!mat2 || (strcmp(mat[i].title, mat2[i].title)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(mat[i].title) && __builtin_constant_p (mat2[i].title
) && (__s1_len = strlen (mat[i].title), __s2_len = strlen
(mat2[i].title), (!((size_t)(const void *)((mat[i].title) + 1
) - (size_t)(const void *)(mat[i].title) == 1) || __s1_len >=
4) && (!((size_t)(const void *)((mat2[i].title) + 1)
- (size_t)(const void *)(mat2[i].title) == 1) || __s2_len >=
4)) ? __builtin_strcmp (mat[i].title, mat2[i].title) : (__builtin_constant_p
(mat[i].title) && ((size_t)(const void *)((mat[i].title
) + 1) - (size_t)(const void *)(mat[i].title) == 1) &&
(__s1_len = strlen (mat[i].title), __s1_len < 4) ? (__builtin_constant_p
(mat2[i].title) && ((size_t)(const void *)((mat2[i].
title) + 1) - (size_t)(const void *)(mat2[i].title) == 1) ? __builtin_strcmp
(mat[i].title, mat2[i].title) : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (mat2[i]
.title); int __result = (((const unsigned char *) (const char
*) (mat[i].title))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat[i].title))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat[i].title))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (mat[i].title))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(mat2[i].title) && ((size_t)(const void *)((mat2[i].
title) + 1) - (size_t)(const void *)(mat2[i].title) == 1) &&
(__s2_len = strlen (mat2[i].title), __s2_len < 4) ? (__builtin_constant_p
(mat[i].title) && ((size_t)(const void *)((mat[i].title
) + 1) - (size_t)(const void *)(mat[i].title) == 1) ? __builtin_strcmp
(mat[i].title, mat2[i].title) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (mat[i].
title); int __result = (((const unsigned char *) (const char *
) (mat2[i].title))[0] - __s2[0]); if (__s2_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat2[i].title))[1] - __s2[1]); if (__s2_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (mat2[i].title))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (mat2[i].title))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(mat[i].title, mat2[i].title)))); }) == 0))
918 {
919 strcpy(buf, mat[i].title);
920 }
921 else
922 {
923 sprintf(buf, "%s / %s", mat[i].title, mat2[i].title);
924 }
925 ps_ctext(out, x0+w/2, y0+box_height(&(mat[i]), psr)+psr->titfontsize,
926 buf, eXCenter);
927 }
928 sprintf(buf, "Here starts the filling of box #%d", i);
929 ps_comment(out, buf);
930 for (x = 0; (x < mat[i].nx); x++)
931 {
932 int nexty;
933 int nextcol;
934
935 xx = x0+x*psr->xboxsize;
936 ps_moveto(out, xx, y0);
937 y = 0;
938 bMap1 = (!mat2 || (x < y || (x == y && bFirstDiag)));
939 if ((bDiag) || (x != y))
940 {
941 col = mat[i].matrix[x][y];
942 }
943 else
944 {
945 col = -1;
946 }
947 for (nexty = 1; (nexty <= mat[i].ny); nexty++)
948 {
949 bNextMap1 = (!mat2 || (x < nexty || (x == nexty && bFirstDiag)));
950 /* TRUE: upper left -> map1 */
951 /* FALSE: lower right -> map2 */
952 if ((nexty == mat[i].ny) || (!bDiag && (x == nexty)))
953 {
954 nextcol = -1;
955 }
956 else
957 {
958 nextcol = mat[i].matrix[x][nexty];
959 }
960 if ( (nexty == mat[i].ny) || (col != nextcol) || (bMap1 != bNextMap1) )
961 {
962 if (col >= 0)
963 {
964 if (bMap1)
965 {
966 ps_rgb_nbox(out, &(mat[i].map[col].rgb), nexty-y);
967 }
968 else
969 {
970 ps_rgb_nbox(out, &(mat2[i].map[col].rgb), nexty-y);
971 }
972 }
973 else
974 {
975 ps_moverel(out, 0, psr->yboxsize);
976 }
977 y = nexty;
978 bMap1 = bNextMap1;
979 col = nextcol;
980 }
981 }
982 }
983 y0 += box_height(&(mat[i]), psr)+box_dh(psr)+box_dh_top(IS_ONCE(i == nmat-1), psr);
984 }
985
986 if (psr->X.lineatzero || psr->Y.lineatzero)
987 {
988 /* reset y0 for first box */
989 y0 = dh;
990 ps_comment(out, "Here starts the zero lines drawing");
991 draw_zerolines(out, x0, y0, w, nmat, mat, psr);
992 }
993
994 if (elegend != elNone)
995 {
996 ps_comment(out, "Now it's legend time!");
997 ps_linewidth(out, psr->linewidth);
998 if (mat2 == NULL((void*)0) || elegend != elSecond)
999 {
1000 bDiscrete = mat[0].bDiscrete;
1001 legend = mat[0].legend;
1002 leg_nmap = nmap1;
1003 leg_map = map1;
1004 }
1005 else
1006 {
1007 bDiscrete = mat2[0].bDiscrete;
1008 legend = mat2[0].legend;
1009 leg_nmap = nmap2;
1010 leg_map = map2;
1011 }
1012 if (bDiscrete)
1013 {
1014 leg_discrete(out, psr->legfontsize, DDD2, legend,
1015 psr->legfontsize, psr->legfont, leg_nmap, leg_map);
1016 }
1017 else
1018 {
1019 if (elegend != elBoth)
1020 {
1021 leg_continuous(out, x0+w/2, w/2, DDD2, legend,
1022 psr->legfontsize, psr->legfont, leg_nmap, leg_map,
1023 mapoffset);
1024 }
1025 else
1026 {
1027 leg_bicontinuous(out, x0+w/2, w, DDD2, mat[0].legend, mat2[0].legend,
1028 psr->legfontsize, psr->legfont, nmap1, map1, nmap2, map2);
1029 }
1030 }
1031 ps_comment(out, "Were there, dude");
1032 }
1033
1034 ps_close(out);
1035}
1036
1037void make_axis_labels(int nmat, t_matrix *mat)
1038{
1039 int i, j;
1040
1041 for (i = 0; (i < nmat); i++)
1042 {
1043 /* Make labels for x axis */
1044 if (mat[i].axis_x == NULL((void*)0))
1045 {
1046 snew(mat[i].axis_x, mat[i].nx)(mat[i].axis_x) = save_calloc("mat[i].axis_x", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 1046, (mat[i].nx), sizeof(*(mat[i].axis_x)));
1047 for (j = 0; (j < mat[i].nx); j++)
1048 {
1049 mat[i].axis_x[j] = j;
1050 }
1051 }
1052 /* Make labels for y axis */
1053 if (mat[i].axis_y == NULL((void*)0))
1054 {
1055 snew(mat[i].axis_y, mat[i].ny)(mat[i].axis_y) = save_calloc("mat[i].axis_y", "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 1055, (mat[i].ny), sizeof(*(mat[i].axis_y)));
1056 for (j = 0; (j < mat[i].ny); j++)
1057 {
1058 mat[i].axis_y[j] = j;
1059 }
1060 }
1061 }
1062}
1063
1064void prune_mat(int nmat, t_matrix *mat, t_matrix *mat2, int skip)
1065{
1066 int i, x, y, xs, ys;
1067
1068 for (i = 0; i < nmat; i++)
1069 {
1070 fprintf(stderrstderr, "converting %dx%d matrix to %dx%d\n",
1071 mat[i].nx, mat[i].ny,
1072 (mat[i].nx+skip-1)/skip, (mat[i].ny+skip-1)/skip);
1073 /* walk through matrix */
1074 xs = 0;
1075 for (x = 0; (x < mat[i].nx); x++)
1076 {
1077 if (x % skip == 0)
1078 {
1079 mat[i].axis_x[xs] = mat[i].axis_x[x];
1080 if (mat2)
1081 {
1082 mat2[i].axis_x[xs] = mat2[i].axis_x[x];
1083 }
1084 ys = 0;
1085 for (y = 0; (y < mat[i].ny); y++)
1086 {
1087 if (x == 0)
1088 {
1089 mat[i].axis_y[ys] = mat[i].axis_y[y];
1090 if (mat2)
1091 {
1092 mat2[i].axis_y[ys] = mat2[i].axis_y[y];
1093 }
1094 }
1095 if (y % skip == 0)
1096 {
1097 mat[i].matrix[xs][ys] = mat[i].matrix[x][y];
1098 if (mat2)
1099 {
1100 mat2[i].matrix[xs][ys] = mat2[i].matrix[x][y];
1101 }
1102 ys++;
1103 }
1104 }
1105 xs++;
1106 }
1107 }
1108 /* adjust parameters */
1109 mat[i].nx = (mat[i].nx+skip-1)/skip;
1110 mat[i].ny = (mat[i].ny+skip-1)/skip;
1111 if (mat2)
1112 {
1113 mat2[i].nx = (mat2[i].nx+skip-1)/skip;
1114 mat2[i].ny = (mat2[i].ny+skip-1)/skip;
1115 }
1116 }
1117}
1118
1119void zero_lines(int nmat, t_matrix *mat, t_matrix *mat2)
1120{
1121 int i, x, y, m;
1122 t_matrix *mats;
1123
1124 for (i = 0; i < nmat; i++)
1125 {
1126 for (m = 0; m < (mat2 ? 2 : 1); m++)
1127 {
1128 if (m == 0)
1129 {
1130 mats = mat;
1131 }
1132 else
1133 {
1134 mats = mat2;
1135 }
1136 for (x = 0; x < mats[i].nx-1; x++)
1137 {
1138 if (abs(mats[i].axis_x[x+1]) < 1e-5)
1139 {
1140 for (y = 0; y < mats[i].ny; y++)
1141 {
1142 mats[i].matrix[x][y] = 0;
1143 }
1144 }
1145 }
1146 for (y = 0; y < mats[i].ny-1; y++)
1147 {
1148 if (abs(mats[i].axis_y[y+1]) < 1e-5)
1149 {
1150 for (x = 0; x < mats[i].nx; x++)
1151 {
1152 mats[i].matrix[x][y] = 0;
1153 }
1154 }
1155 }
1156 }
1157 }
1158}
1159
1160void write_combined_matrix(int ecombine, const char *fn,
1161 int nmat, t_matrix *mat1, t_matrix *mat2,
1162 real *cmin, real *cmax)
1163{
1164 int i, j, k, nlevels;
1165 t_mapping *map = NULL((void*)0);
1166 FILE *out;
1167 real **rmat1, **rmat2;
1168 real rhi, rlo;
1169
1170 out = gmx_ffopen(fn, "w");
1171 for (k = 0; k < nmat; k++)
1172 {
1173 if (mat2[k].nx != mat1[k].nx || mat2[k].ny != mat1[k].ny)
1174 {
1175 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 1175, "Size of frame %d in 1st (%dx%d) and 2nd matrix (%dx%d) do"
1176 " not match.\n", k, mat1[k].nx, mat1[k].ny, mat2[k].nx, mat2[k].ny);
1177 }
1178 printf("Combining two %dx%d matrices\n", mat1[k].nx, mat1[k].ny);
1179 rmat1 = matrix2real(&mat1[k], NULL((void*)0));
1180 rmat2 = matrix2real(&mat2[k], NULL((void*)0));
1181 if (NULL((void*)0) == rmat1 || NULL((void*)0) == rmat2)
1182 {
1183 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 1183, "Could not extract real data from %s xpm matrices. Note that, e.g.,\n"
1184 "g_rms and g_mdmat provide such data, but not do_dssp.\n",
1185 (NULL((void*)0) == rmat1 && NULL((void*)0) == rmat2) ? "both" : "one of the" );
1186 }
1187 rlo = 1e38;
1188 rhi = -1e38;
1189 for (j = 0; j < mat1[k].ny; j++)
1190 {
1191 for (i = 0; i < mat1[k].nx; i++)
1192 {
1193 switch (ecombine)
1194 {
1195 case ecAdd: rmat1[i][j] += rmat2[i][j]; break;
1196 case ecSub: rmat1[i][j] -= rmat2[i][j]; break;
1197 case ecMult: rmat1[i][j] *= rmat2[i][j]; break;
1198 case ecDiv: rmat1[i][j] /= rmat2[i][j]; break;
1199 default:
1200 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 1200, "No such combination rule %d for matrices", ecombine);
1201 }
1202 rlo = min(rlo, rmat1[i][j])(((rlo) < (rmat1[i][j])) ? (rlo) : (rmat1[i][j]) );
1203 rhi = max(rhi, rmat1[i][j])(((rhi) > (rmat1[i][j])) ? (rhi) : (rmat1[i][j]) );
1204 }
1205 }
1206 if (cmin)
1207 {
1208 rlo = *cmin;
1209 }
1210 if (cmax)
1211 {
1212 rhi = *cmax;
1213 }
1214 nlevels = max(mat1[k].nmap, mat2[k].nmap)(((mat1[k].nmap) > (mat2[k].nmap)) ? (mat1[k].nmap) : (mat2
[k].nmap) );
1215 if (rhi == rlo)
1216 {
1217 fprintf(stderrstderr,
1218 "combination results in uniform matrix (%g), no output\n", rhi);
1219 }
1220 /*
1221 else if (rlo>=0 || rhi<=0)
1222 write_xpm(out, mat1[k].flags, mat1[k].title, mat1[k].legend,
1223 mat1[k].label_x, mat1[k].label_y,
1224 mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
1225 rmat1, rlo, rhi, rhi<=0?red:white, rhi<=0?white:blue,
1226 &nlevels);
1227 else
1228 write_xpm3(out, mat2[k].flags, mat1[k].title, mat1[k].legend,
1229 mat1[k].label_x, mat1[k].label_y,
1230 mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
1231 rmat1, rlo, 0, rhi, red, white, blue, &nlevels);
1232 */
1233 else
1234 {
1235 write_xpm(out, mat1[k].flags, mat1[k].title, mat1[k].legend,
1236 mat1[k].label_x, mat1[k].label_y,
1237 mat1[k].nx, mat1[k].ny, mat1[k].axis_x, mat1[k].axis_y,
1238 rmat1, rlo, rhi, white, black, &nlevels);
1239 }
1240 }
1241 gmx_ffclose(out);
1242}
1243
1244void do_mat(int nmat, t_matrix *mat, t_matrix *mat2,
1245 gmx_bool bFrame, gmx_bool bZeroLine, gmx_bool bDiag, gmx_bool bFirstDiag, gmx_bool bTitle,
1246 gmx_bool bTitleOnce, gmx_bool bYonce, int elegend,
1247 real size, real boxx, real boxy,
1248 const char *epsfile, const char *xpmfile, const char *m2p,
1249 const char *m2pout, int skip, int mapoffset)
1250{
1251 int i, j, k;
1252
1253 if (mat2)
1254 {
1255 for (k = 0; (k < nmat); k++)
1256 {
1257 if ((mat2[k].nx != mat[k].nx) || (mat2[k].ny != mat[k].ny))
1258 {
1259 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 1259, "WAKE UP!! Size of frame %d in 2nd matrix file (%dx%d) does not match size of 1st matrix (%dx%d) or the other way around.\n",
1260 k, mat2[k].nx, mat2[k].ny, mat[k].nx, mat[k].ny);
1261 }
1262 for (j = 0; (j < mat[k].ny); j++)
1263 {
1264 for (i = bFirstDiag ? j+1 : j; (i < mat[k].nx); i++)
1265 {
1266 mat[k].matrix[i][j] = mat2[k].matrix[i][j];
1267 }
1268 }
1269 }
1270 }
1271 for (i = 0; (i < nmat); i++)
1272 {
1273 fprintf(stderrstderr, "Matrix %d is %d x %d\n", i, mat[i].nx, mat[i].ny);
1274 }
1275
1276 make_axis_labels(nmat, mat);
1277
1278 if (skip > 1)
1279 {
1280 prune_mat(nmat, mat, mat2, skip);
1281 }
1282
1283 if (bZeroLine)
1284 {
1285 zero_lines(nmat, mat, mat);
1286 }
1287
1288 if (epsfile != NULL((void*)0))
1289 {
1290 ps_mat(epsfile, nmat, mat, mat2, bFrame, bDiag, bFirstDiag,
1291 bTitle, bTitleOnce, bYonce, elegend,
1292 size, boxx, boxy, m2p, m2pout, mapoffset);
1293 }
1294 if (xpmfile != NULL((void*)0))
1295 {
1296 xpm_mat(xpmfile, nmat, mat, mat2, bDiag, bFirstDiag);
1297 }
1298}
1299
1300void gradient_map(rvec grad, int nmap, t_mapping map[])
1301{
1302 int i;
1303 real c;
1304
1305 for (i = 0; i < nmap; i++)
1306 {
1307 c = i/(nmap-1.0);
1308 map[i].rgb.r = 1-c*(1-grad[XX0]);
1309 map[i].rgb.g = 1-c*(1-grad[YY1]);
1310 map[i].rgb.b = 1-c*(1-grad[ZZ2]);
1311 }
1312}
1313
1314void gradient_mat(rvec grad, int nmat, t_matrix mat[])
1315{
1316 int m;
1317
1318 for (m = 0; m < nmat; m++)
1319 {
1320 gradient_map(grad, mat[m].nmap, mat[m].map);
1321 }
1322}
1323
1324void rainbow_map(gmx_bool bBlue, int nmap, t_mapping map[])
1325{
1326 int i;
1327 real c, r, g, b;
1328
1329 for (i = 0; i < nmap; i++)
1330 {
1331 c = (map[i].rgb.r + map[i].rgb.g + map[i].rgb.b)/3;
1332 if (c > 1)
1333 {
1334 c = 1;
1335 }
1336 if (bBlue)
1337 {
1338 c = 1 - c;
1339 }
1340 if (c <= 0.25) /* 0-0.25 */
1341 {
1342 r = 0;
1343 g = pow(4*c, 0.666);
1344 b = 1;
1345 }
1346 else if (c <= 0.5) /* 0.25-0.5 */
1347 {
1348 r = 0;
1349 g = 1;
1350 b = pow(2-4*c, 0.666);
1351 }
1352 else if (c <= 0.75) /* 0.5-0.75 */
1353 {
1354 r = pow(4*c-2, 0.666);
1355 g = 1;
1356 b = 0;
1357 }
1358 else /* 0.75-1 */
1359 {
1360 r = 1;
1361 g = pow(4-4*c, 0.666);
1362 b = 0;
1363 }
1364 map[i].rgb.r = r;
1365 map[i].rgb.g = g;
1366 map[i].rgb.b = b;
1367 }
1368}
1369
1370void rainbow_mat(gmx_bool bBlue, int nmat, t_matrix mat[])
1371{
1372 int m;
1373
1374 for (m = 0; m < nmat; m++)
1375 {
1376 rainbow_map(bBlue, mat[m].nmap, mat[m].map);
1377 }
1378}
1379
1380int gmx_xpm2ps(int argc, char *argv[])
1381{
1382 const char *desc[] = {
1383 "[THISMODULE] makes a beautiful color plot of an XPixelMap file.",
1384 "Labels and axis can be displayed, when they are supplied",
1385 "in the correct matrix format.",
1386 "Matrix data may be generated by programs such as [gmx-do_dssp], [gmx-rms] or",
1387 "[gmx-mdmat].[PAR]",
1388 "Parameters are set in the [TT].m2p[tt] file optionally supplied with",
1389 "[TT]-di[tt]. Reasonable defaults are provided. Settings for the [IT]y[it]-axis",
1390 "default to those for the [IT]x[it]-axis. Font names have a defaulting hierarchy:",
1391 "titlefont -> legendfont; titlefont -> (xfont -> yfont -> ytickfont)",
1392 "-> xtickfont, e.g. setting titlefont sets all fonts, setting xfont",
1393 "sets yfont, ytickfont and xtickfont.[PAR]",
1394 "When no [TT].m2p[tt] file is supplied, many settings are taken from",
1395 "command line options. The most important option is [TT]-size[tt],",
1396 "which sets the size of the whole matrix in postscript units.",
1397 "This option can be overridden with the [TT]-bx[tt] and [TT]-by[tt]",
1398 "options (and the corresponding parameters in the [TT].m2p[tt] file),",
1399 "which set the size of a single matrix element.[PAR]",
1400 "With [TT]-f2[tt] a second matrix file can be supplied. Both matrix",
1401 "files will be read simultaneously and the upper left half of the",
1402 "first one ([TT]-f[tt]) is plotted together with the lower right",
1403 "half of the second one ([TT]-f2[tt]). The diagonal will contain",
1404 "values from the matrix file selected with [TT]-diag[tt].",
1405 "Plotting of the diagonal values can be suppressed altogether by",
1406 "setting [TT]-diag[tt] to [TT]none[tt].",
1407 "In this case, a new color map will be generated with",
1408 "a red gradient for negative numbers and a blue for positive.",
1409 "If the color coding and legend labels of both matrices are identical,",
1410 "only one legend will be displayed, else two separate legends are",
1411 "displayed.",
1412 "With [TT]-combine[tt], an alternative operation can be selected",
1413 "to combine the matrices. The output range is automatically set",
1414 "to the actual range of the combined matrix. This can be overridden",
1415 "with [TT]-cmin[tt] and [TT]-cmax[tt].[PAR]",
1416 "[TT]-title[tt] can be set to [TT]none[tt] to suppress the title, or to",
1417 "[TT]ylabel[tt] to show the title in the Y-label position (alongside",
1418 "the [IT]y[it]-axis).[PAR]",
1419 "With the [TT]-rainbow[tt] option, dull grayscale matrices can be turned",
1420 "into attractive color pictures.[PAR]",
1421 "Merged or rainbowed matrices can be written to an XPixelMap file with",
1422 "the [TT]-xpm[tt] option."
1423 };
1424
1425 output_env_t oenv;
1426 const char *fn, *epsfile = NULL((void*)0), *xpmfile = NULL((void*)0);
1427 int i, nmat, nmat2, etitle, elegend, ediag, erainbow, ecombine;
1428 t_matrix *mat = NULL((void*)0), *mat2 = NULL((void*)0);
1429 gmx_bool bTitle, bTitleOnce, bDiag, bFirstDiag, bGrad;
1430 static gmx_bool bFrame = TRUE1, bZeroLine = FALSE0, bYonce = FALSE0, bAdd = FALSE0;
1431 static real size = 400, boxx = 0, boxy = 0, cmin = 0, cmax = 0;
1432 static rvec grad = {0, 0, 0};
1433 enum {
1434 etSel, etTop, etOnce, etYlabel, etNone, etNR
1435 };
1436 const char *title[] = { NULL((void*)0), "top", "once", "ylabel", "none", NULL((void*)0) };
1437 /* MUST correspond to enum elXxx as defined at top of file */
1438 const char *legend[] = { NULL((void*)0), "both", "first", "second", "none", NULL((void*)0) };
1439 enum {
1440 edSel, edFirst, edSecond, edNone, edNR
1441 };
1442 const char *diag[] = { NULL((void*)0), "first", "second", "none", NULL((void*)0) };
1443 enum {
1444 erSel, erNo, erBlue, erRed, erNR
1445 };
1446 const char *rainbow[] = { NULL((void*)0), "no", "blue", "red", NULL((void*)0) };
1447 /* MUST correspond to enum ecXxx as defined at top of file */
1448 const char *combine[] = {
1449 NULL((void*)0), "halves", "add", "sub", "mult", "div", NULL((void*)0)
1450 };
1451 static int skip = 1, mapoffset = 0;
1452 t_pargs pa[] = {
1453 { "-frame", FALSE0, etBOOL, {&bFrame},
1454 "Display frame, ticks, labels, title and legend" },
1455 { "-title", FALSE0, etENUM, {title}, "Show title at" },
1456 { "-yonce", FALSE0, etBOOL, {&bYonce}, "Show y-label only once" },
1457 { "-legend", FALSE0, etENUM, {legend}, "Show legend" },
1458 { "-diag", FALSE0, etENUM, {diag}, "Diagonal" },
1459 { "-size", FALSE0, etREAL, {&size},
1460 "Horizontal size of the matrix in ps units" },
1461 { "-bx", FALSE0, etREAL, {&boxx},
1462 "Element x-size, overrides [TT]-size[tt] (also y-size when [TT]-by[tt] is not set)" },
1463 { "-by", FALSE0, etREAL, {&boxy}, "Element y-size" },
1464 { "-rainbow", FALSE0, etENUM, {rainbow},
1465 "Rainbow colors, convert white to" },
1466 { "-gradient", FALSE0, etRVEC, {grad},
1467 "Re-scale colormap to a smooth gradient from white {1,1,1} to {r,g,b}" },
1468 { "-skip", FALSE0, etINT, {&skip},
1469 "only write out every nr-th row and column" },
1470 { "-zeroline", FALSE0, etBOOL, {&bZeroLine},
1471 "insert line in [TT].xpm[tt] matrix where axis label is zero"},
1472 { "-legoffset", FALSE0, etINT, {&mapoffset},
1473 "Skip first N colors from [TT].xpm[tt] file for the legend" },
1474 { "-combine", FALSE0, etENUM, {combine}, "Combine two matrices" },
1475 { "-cmin", FALSE0, etREAL, {&cmin}, "Minimum for combination output" },
1476 { "-cmax", FALSE0, etREAL, {&cmax}, "Maximum for combination output" }
1477 };
1478#define NPA((int)(sizeof(pa)/sizeof((pa)[0]))) asize(pa)((int)(sizeof(pa)/sizeof((pa)[0])))
1479 t_filenm fnm[] = {
1480 { efXPM, "-f", NULL((void*)0), ffREAD1<<1 },
1481 { efXPM, "-f2", "root2", ffOPTRD(1<<1 | 1<<3) },
1482 { efM2P, "-di", NULL((void*)0), ffLIBOPTRD((1<<1 | 1<<3) | 1<<4) },
1483 { efM2P, "-do", "out", ffOPTWR(1<<2| 1<<3) },
1484 { efEPS, "-o", NULL((void*)0), ffOPTWR(1<<2| 1<<3) },
1485 { efXPM, "-xpm", NULL((void*)0), ffOPTWR(1<<2| 1<<3) }
1486 };
1487#define NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))) asize(fnm)((int)(sizeof(fnm)/sizeof((fnm)[0])))
1488
1489 if (!parse_common_args(&argc, argv, PCA_CAN_VIEW(1<<5),
1490 NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm, NPA((int)(sizeof(pa)/sizeof((pa)[0]))), pa,
1491 asize(desc)((int)(sizeof(desc)/sizeof((desc)[0]))), desc, 0, NULL((void*)0), &oenv))
1492 {
1493 return 0;
1494 }
1495
1496 etitle = nenum(title);
1497 elegend = nenum(legend);
1498 ediag = nenum(diag);
1499 erainbow = nenum(rainbow);
1500 ecombine = nenum(combine);
1501 bGrad = opt2parg_bSet("-gradient", NPA((int)(sizeof(pa)/sizeof((pa)[0]))), pa);
1502 for (i = 0; i < DIM3; i++)
1503 {
1504 if (grad[i] < 0 || grad[i] > 1)
1505 {
1506 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxana/gmx_xpm2ps.c"
, 1506, "RGB value %g out of range (0.0-1.0)", grad[i]);
1507 }
1508 }
1509 if (!bFrame)
1510 {
1511 etitle = etNone;
1512 elegend = elNone;
1513 }
1514
1515 epsfile = ftp2fn_null(efEPS, NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm);
1516 xpmfile = opt2fn_null("-xpm", NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm);
1517 if (epsfile == NULL((void*)0) && xpmfile == NULL((void*)0))
1518 {
1519 if (ecombine != ecHalves)
1520 {
1521 xpmfile = opt2fn("-xpm", NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm);
1522 }
1523 else
1524 {
1525 epsfile = ftp2fn(efEPS, NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm);
1526 }
1527 }
1528 if (ecombine != ecHalves && epsfile)
1529 {
1530 fprintf(stderrstderr,
1531 "WARNING: can only write result of arithmetic combination "
1532 "of two matrices to .xpm file\n"
1533 " file %s will not be written\n", epsfile);
1534 epsfile = NULL((void*)0);
1535 }
1536
1537 bDiag = ediag != edNone;
1538 bFirstDiag = ediag != edSecond;
1539
1540 fn = opt2fn("-f", NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm);
1541 nmat = read_xpm_matrix(fn, &mat);
1542 fprintf(stderrstderr, "There %s %d matri%s in %s\n", (nmat > 1) ? "are" : "is", nmat, (nmat > 1) ? "ces" : "x", fn);
1543 fn = opt2fn_null("-f2", NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm);
1544 if (fn)
1545 {
1546 nmat2 = read_xpm_matrix(fn, &mat2);
1547 fprintf(stderrstderr, "There %s %d matri%s in %s\n", (nmat2 > 1) ? "are" : "is", nmat2, (nmat2 > 1) ? "ces" : "x", fn);
1548 if (nmat != nmat2)
1549 {
1550 fprintf(stderrstderr, "Different number of matrices, using the smallest number.\n");
1551 nmat = nmat2 = min(nmat, nmat2)(((nmat) < (nmat2)) ? (nmat) : (nmat2) );
1552 }
1553 }
1554 else
1555 {
1556 if (ecombine != ecHalves)
1557 {
1558 fprintf(stderrstderr,
1559 "WARNING: arithmetic matrix combination selected (-combine), "
1560 "but no second matrix (-f2) supplied\n"
1561 " no matrix combination will be performed\n");
1562 }
1563 ecombine = 0;
1564 nmat2 = 0;
1565 }
1566 bTitle = etitle == etTop;
1567 bTitleOnce = etitle == etOnce;
1568 if (etitle == etYlabel)
1569 {
1570 for (i = 0; (i < nmat); i++)
1571 {
1572 strcpy(mat[i].label_y, mat[i].title);
1573 if (mat2)
1574 {
1575 strcpy(mat2[i].label_y, mat2[i].title);
1576 }
1577 }
1578 }
1579 if (bGrad)
1580 {
1581 gradient_mat(grad, nmat, mat);
1582 if (mat2)
1583 {
1584 gradient_mat(grad, nmat2, mat2);
1585 }
1586 }
1587 if (erainbow != erNo)
1588 {
1589 rainbow_mat(erainbow == erBlue, nmat, mat);
1590 if (mat2)
1591 {
1592 rainbow_mat(erainbow == erBlue, nmat2, mat2);
1593 }
1594 }
1595
1596 if ((mat2 == NULL((void*)0)) && (elegend != elNone))
1597 {
1598 elegend = elFirst;
1599 }
1600
1601 if (ecombine && ecombine != ecHalves)
1602 {
1603 write_combined_matrix(ecombine, xpmfile, nmat, mat, mat2,
1604 opt2parg_bSet("-cmin", NPA((int)(sizeof(pa)/sizeof((pa)[0]))), pa) ? &cmin : NULL((void*)0),
1605 opt2parg_bSet("-cmax", NPA((int)(sizeof(pa)/sizeof((pa)[0]))), pa) ? &cmax : NULL((void*)0));
1606 }
1607 else
1608 {
1609 do_mat(nmat, mat, mat2, bFrame, bZeroLine, bDiag, bFirstDiag,
1610 bTitle, bTitleOnce, bYonce,
1611 elegend, size, boxx, boxy, epsfile, xpmfile,
1612 opt2fn_null("-di", NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm), opt2fn_null("-do", NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm), skip,
1613 mapoffset);
1614 }
1615
1616 view_all(oenv, NFILE((int)(sizeof(fnm)/sizeof((fnm)[0]))), fnm);
1617
1618 return 0;
1619}