File: color_size.c

package info (click to toggle)
garlic 1.6-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 4,516 kB
  • sloc: ansic: 52,465; makefile: 2,254
file content (179 lines) | stat: -rw-r--r-- 4,947 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
/* Copyright (C) 2003 Damir Zucic */

/*=============================================================================

				    color_size.c

Purpose:
	Size color scheme: assign colors according to the side chain size.
	The smallest residue  (GLY) will be colored  blue and  the largest
	residue  (TRP) will be colored  red.  The size  is defined  as the
	total number of carbon, oxygen and nitrogen atoms.


Input:
	(1) Pointer to MolComplexS structure, with macromol. complexes.
	(2) Number of macromolecular complexes.
	(3) Pointer to GUIS structure, with GUI data.
	(4) Pointer to ColorSchemeS structure.

Output:
	(1) Return value.

Return value:
	(1) Positive always.

=============================================================================*/

#include <stdio.h>

#include <string.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Xatom.h>

#include "defines.h"
#include "typedefs.h"

/*======function prototypes:=================================================*/

int		MixColors_ (AtomS *, ColorSchemeS *, ColorSchemeS *,
			    double, GUIS *);

/*======size color scheme:===================================================*/

int ColorSize_ (MolComplexS *mol_complexSP, int mol_complexesN,
		GUIS *guiSP, ColorSchemeS *color_schemeSP)
{
size_t		rgb_struct_size;
ColorSchemeS	*blue_schemeSP, *white_schemeSP, *red_schemeSP;
static double	min_size = 0, threshold_size = 4, max_size = 10;
double		delta_size1, delta_size2;
double		inverse_range1, inverse_range2;
int		mol_complexI;
MolComplexS	*curr_mol_complexSP;
int		residuesN, residueI;
ResidueS	*residueSP;
AtomS		*first_atomSP;
char		*residue_nameP;
int		i;
static char	amino_acidAA[23][4] =
		{"ALA","ARG","ASN","ASP","CYS","GLN","GLU","GLY","HIS","ILE",
		 "LEU","LYS","MET","PHE","PRO","SER","THR","TRP","TYR","VAL",
		 "ASX","GLX","UNK"};
static double	res_sizeA[23] =
		{ 1.0,  7.0,  4.0,  4.0,  2.0,  5.0,  5.0,  0.0,  6.0,  4.0,
		  4.0,  5.0,  4.0,  7.0,  3.0,  2.0,  3.0, 10.0,  8.0,  3.0,
		  4.0,  5.0,  5.0 }; 
double		res_size;
size_t		startI, endI, atomI;
AtomS		*atomSP;
double		scale_factor;

/* The size of RGBS structure: */
rgb_struct_size = sizeof (RGBS);

/* Red scheme pointer: */
red_schemeSP = color_schemeSP + 0;

/* White scheme pointer: */
white_schemeSP = color_schemeSP + 6;

/* Blue scheme pointer: */
blue_schemeSP = color_schemeSP + 2;

/* Inverse size ranges: */
delta_size1 = max_size - threshold_size;
if (delta_size1 != 0.0) inverse_range1 = 1.0 / delta_size1;
else inverse_range1 = 0.0;
delta_size2 = threshold_size - min_size;
if (delta_size2 != 0.0) inverse_range2 = 1.0 / delta_size2;
else inverse_range2 = 0.0;

/* Scan every macromolecular complex: */
for (mol_complexI = 0; mol_complexI < mol_complexesN; mol_complexI++)
	{
	/* Pointer to the current macromolecular complex: */
	curr_mol_complexSP = mol_complexSP + mol_complexI;

	/* Check is the current macromolecular complex caught: */
	if (curr_mol_complexSP->catchF == 0) continue;

	/* Copy and check the number of residues: */
	residuesN = curr_mol_complexSP->residuesN;
	if (residuesN == 0) continue;

	/* Scan the macromolecular complex, residue by residue: */
	for (residueI = 0; residueI < residuesN; residueI++)
		{
		/* Pointer to the current residue: */
		residueSP = mol_complexSP->residueSP + residueI;

		/* Pointer to the first atom of this residue: */
		first_atomSP = mol_complexSP->atomSP +
			       residueSP->residue_startI;

		/* Pointer to the residue name: */
		residue_nameP = first_atomSP->raw_atomS.pure_residue_nameA;

		/* The threshold value is used as default: */
		res_size = threshold_size;

		/* Compare the purified residue name with 23 standard names: */
		for (i = 0; i < 23; i++)
			{
			/* If amino acid is recognized: */
			if (strcmp (residue_nameP, amino_acidAA[i]) == 0)
				{
				res_size = res_sizeA[i];
				break;
				}
			}

		/* All atoms of this residue should be colored: */

		/* The range of atomic indices for the current residue: */
		startI = residueSP->residue_startI;
		endI   = residueSP->residue_endI;

		/* Scan the whole residue: */
		for (atomI = startI; atomI <= endI; atomI++)
			{
			/* Pointer to the current atom: */ 
			atomSP = mol_complexSP->atomSP + atomI;

			/* If residue size is below threshold value: */
			if (res_size <= threshold_size)
				{
				scale_factor = (threshold_size - res_size) *
						inverse_range2;
				MixColors_ (atomSP,
					    white_schemeSP, blue_schemeSP,
					    scale_factor, guiSP);
				}

			/* If residue size is above threshold value: */
			else
				{
				scale_factor = (res_size - threshold_size) *
						inverse_range1;
				MixColors_ (atomSP,
					    white_schemeSP, red_schemeSP,
					    scale_factor, guiSP);
				}
			}
		}

	/* Reset the position_changedF: */
	curr_mol_complexSP->position_changedF = 1;
	}

/* Return positive value: */
return 1;
}

/*===========================================================================*/