xyz2pov/src/pov_writer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "pov_writer.h"
#include "atom_parser.h"

struct bond{
  int i;
  int j;
};

struct linked_bond_list{
  struct bond the_bond;
  struct linked_bond_list *next;
};

void make_bonds(struct coords *, int);

struct linked_bond_list *bl_head;
  
void clean_bonds(void);


void pov_write(FILE *out_file, struct coords *the_coords, int n_atoms,
               int d_hydrogens, int d_bonds, int d_atoms){

  int i,j; /*loop counters */
  int skip_atom, skip_bond, test1, test2; /*booleans */
  double dx, dy, dz; /* used in making the bonds */
  
  struct linked_bond_list *current_bond; /*keeps track of the linked list*/

  for(i = 0; i < n_atoms; i++){
    update_types(the_coords[i].name);
  }  
  
  if(d_atoms){
    
    fprintf(out_file,
            "//************************************************************\n"
            "// The list of atoms\n"
            "//************************************************************\n"
            "\n"
            "\n");

    for(i = 0; i < n_atoms; i++){
      
      skip_atom = 0;
      
      if(!d_hydrogens){
        skip_atom = !strcmp("H", the_coords[i].name);
      }
      
      if(!skip_atom){
        
        fprintf(out_file, 
                "make_%s_atom( %lf, %lf, %lf )\n",
                the_coords[i].name,
                the_coords[i].x,
                the_coords[i].z,
                the_coords[i].y);
      }
    }
    
    fprintf(out_file,
            "\n"
            "\n");
    
  }
  
  if(d_bonds){
    
    fprintf(out_file,
            "//************************************************************\n"
            "// The list of bonds\n"
            "//************************************************************\n"
            "\n"
            "\n");
    
    make_bonds(the_coords, n_atoms);
    
    current_bond = bl_head->next;
    
    while(current_bond != NULL){
      
      skip_bond = 0;
      
      i = current_bond->the_bond.i;
      j = current_bond->the_bond.j;
      
      if(!d_hydrogens){

        test1 = !strcmp("H", the_coords[i].name);
        test2 = !strcmp("H", the_coords[j].name);

        skip_bond = (test1 || test2);
      }

      if(!skip_bond){
        
        dx = (the_coords[j].x - the_coords[i].x) / 2.0;
        dy = (the_coords[j].y - the_coords[i].y) / 2.0;
        dz = (the_coords[j].z - the_coords[i].z) / 2.0;
        
        fprintf(out_file,
               "make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
               the_coords[i].name,
               the_coords[i].x,
               the_coords[i].z,
               the_coords[i].y,
               (the_coords[i].x + dx),
               (the_coords[i].z + dz),
               (the_coords[i].y + dy));
        
        fprintf(out_file,
               "make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
               the_coords[j].name,
               the_coords[j].x,
               the_coords[j].z,
               the_coords[j].y,
               (the_coords[j].x - dx),
               (the_coords[j].z - dz),
               (the_coords[j].y - dy));

        fprintf(out_file, "\n");
      }
      
      current_bond = current_bond->next;
    }
  
    clean_bonds();
  }
}


void make_bonds(struct coords *the_coords, int n_atoms){
  
  int i, j; /*counters */
  struct linked_bond_list *temp_bond; /*bond place holder */
  
  const double bond_fudge = 1.12; // a fudge factor
  struct atom type_i, type_j; /* holds the atom types */

  int test; /* booleans */
  double dx, dy, dz, dr2, dcv, dcv2; // used to determine bond existence 

  
  bl_head = (struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
  bl_head->next = NULL;

  for(i = 0; i < (n_atoms - 1); i++){
    
    for(j = (i+1); j < n_atoms; j++){
      
      dx = the_coords[j].x - the_coords[i].x;
      dy = the_coords[j].y - the_coords[i].y;
      dz = the_coords[j].z - the_coords[i].z;
      
      dr2 = dx * dx + dy * dy + dz * dz;
      
      test = !findAtomType(the_coords[i].name, &type_i);
      if(test){
        fprintf(stderr, "Atom Type %s, not found!\n",
                the_coords[i].name);
        exit(8);
      }

      test = !findAtomType(the_coords[j].name, &type_j);
      if(test){
        fprintf(stderr, "Atom Type %s, not found!\n",
                the_coords[j].name);
        exit(8);
      }
      
      
      dcv = bond_fudge * (type_i.covalentRadii + type_j.covalentRadii);
      dcv2 = dcv * dcv;

      if(dr2 <= dcv2){
        
        temp_bond = 
          (struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
        
        bl_head->the_bond.i = i;
        bl_head->the_bond.j = j;
        
        temp_bond->next = bl_head;
        bl_head = temp_bond;
      }
    }
  }
}
        

void clean_bonds(){
  struct linked_bond_list *current_bond;
  struct linked_bond_list *next_bond; /* place holders */
  

    current_bond = bl_head->next;

    while(current_bond != NULL){

      next_bond = current_bond->next;
      free(current_bond);
      current_bond = next_bond;
    }
    
    bl_head->next = NULL;
}


void make_header_macros(FILE *out_file){

  struct linked_atom *type_list;  // list of all atom types
  struct linked_atom *current_type; // current atom type

  char *name;
  double red, green, blue;
  double radius;
  
  type_list = get_type_list();
  current_type = type_list->next;
  
  while(current_type != NULL){
    
    name = current_type->myAtom.name;
    radius = current_type->myAtom.vanDerWallRadii;
    red = ((double)current_type->myAtom.red) / 255.0;
    green =  ((double)current_type->myAtom.green) / 255.0;
    blue =  ((double)current_type->myAtom.blue) / 255.0;

    
    fprintf(out_file,
            "//****************************************************\n"
            "// DEFINE %s MACROS\n" 
            "//****************************************************\n"
            "\n"
            "#macro make_%s_bond "
            "(end_1x, end_1y, end_1z, end_2x, end_2y, end_2z)\n"
            "\n"
            "  #local x1 = end_1x;\n"
            "  #local y1 = end_1y;\n"
            "  #local z1 = end_1z;\n"
            "  #local x2 = end_2x;\n"
            "  #local y2 = end_2y;\n"
            "  #local z2 = end_2z;\n"
            "\n"
            "  #if(ROTATE)\n"
            "    #local x1_new = A11 * x1 + A12 * y1 + A13 * z1;\n"
            "    #local y1_new = A21 * x1 + A22 * y1 + A23 * z1;\n"
            "    #local z1_new = A31 * x1 + A32 * y1 + A33 * z1;\n"
            "\n"
            "    #local x2_new = A11 * x2 + A12 * y2 + A13 * z2;\n"
            "    #local y2_new = A21 * x2 + A22 * y2 + A23 * z2;\n"
            "    #local z2_new = A31 * x2 + A32 * y2 + A33 * z2;\n"
            "\n"
            "  #else\n"
            "    #local x1_new = x1;"
            "    #local y1_new = y1;"
            "    #local z1_new = z1;"
            "\n"
            "    #local x2_new = x2;"
            "    #local y2_new = y2;"
            "    #local z2_new = z2;"
            "\n"
            "  #end\n"
            "\n"
            "  cylinder{\n"
            "    < x1_new, y1_new, z1_new >,\n"
            "    < x2_new, y2_new, z2_new >,\n"
            "    BOND_RADIUS\n"
            "    texture{\n"
            "      pigment{ rgb < %lf, %lf, %lf > }\n"
            "      finish{\n"
            "        ambient .2\n"
            "        diffuse .6\n"
            "        specular 1\n"
            "        roughness .001\n"
            "        metallic\n"
            "      }\n"
            "    }\n"
            "  }\n"
            "#end\n"
            "#macro make_%s_atom "
            "(center_x, center_y, center_z)\n"
                    "\n"
            "  #local x1 = center_x;\n"
            "  #local y1 = center_y;\n"
            "  #local z1 = center_z;\n"
            "\n"
            "  #if(ROTATE)\n"
            "\n"
            "    #local x1_new = A11 * x1 + A12 * y1 + A13 * z1;\n"
            "    #local y1_new = A21 * x1 + A22 * y1 + A23 * z1;\n"
            "    #local z1_new = A31 * x1 + A32 * y1 + A33 * z1;\n"
            "\n"
            "  #else\n"
            "\n"
            "    #local x1_new = x1;"
            "    #local y1_new = y1;"
            "    #local z1_new = z1;"
            "\n"
            "  #end\n"
            "\n"
            "  sphere{\n"
            "    < x1_new, y1_new, z1_new >,\n"
            "    ATOM_SPHERE_FACTOR * %lf\n"
            "    texture{\n"
            "      pigment{ rgb < %lf, %lf, %lf > }\n"
            "      finish{\n"
            "        ambient .2\n"
            "        diffuse .6\n"
            "        specular 1\n"
            "        roughness .001\n"
            "        metallic\n"
            "      }\n"
            "    }\n"
            "  }\n"
            "#end\n"
            "\n"
            "\n",
            name,
            name,
            red, green, blue,
            name,
            radius,
            red, green, blue);
    
    current_type = current_type->next;
  }
}
Revision:	61
Committed:	Thu Aug 1 21:12:33 2002 UTC (21 years, 11 months ago) by mmeineke
Content type:	text/plain
File size:	7920 byte(s)
Log Message:	This commit was generated by cvs2svn to compensate for changes in r60, which included commits to RCS files with non-trunk default branches.
#	Content
1	#include <stdio.h>
2	#include <stdlib.h>
3	#include <string.h>
4	#include <math.h>
5
6	#include "pov_writer.h"
7	#include "atom_parser.h"
8
9	struct bond{
10	int i;
11	int j;
12	};
13
14	struct linked_bond_list{
15	struct bond the_bond;
16	struct linked_bond_list *next;
17	};
18
19	void make_bonds(struct coords *, int);
20
21	struct linked_bond_list *bl_head;
22
23	void clean_bonds(void);
24
25
26	void pov_write(FILE out_file, struct coords the_coords, int n_atoms,
27	int d_hydrogens, int d_bonds, int d_atoms){
28
29	int i,j; /loop counters /
30	int skip_atom, skip_bond, test1, test2; /booleans /
31	double dx, dy, dz; /* used in making the bonds */
32
33	struct linked_bond_list current_bond; /keeps track of the linked list*/
34
35	for(i = 0; i < n_atoms; i++){
36	update_types(the_coords[i].name);
37	}
38
39	if(d_atoms){
40
41	fprintf(out_file,
42	"//************************************************************\n"
43	"// The list of atoms\n"
44	"//************************************************************\n"
45	"\n"
46	"\n");
47
48	for(i = 0; i < n_atoms; i++){
49
50	skip_atom = 0;
51
52	if(!d_hydrogens){
53	skip_atom = !strcmp("H", the_coords[i].name);
54	}
55
56	if(!skip_atom){
57
58	fprintf(out_file,
59	"make_%s_atom( %lf, %lf, %lf )\n",
60	the_coords[i].name,
61	the_coords[i].x,
62	the_coords[i].z,
63	the_coords[i].y);
64	}
65	}
66
67	fprintf(out_file,
68	"\n"
69	"\n");
70
71	}
72
73	if(d_bonds){
74
75	fprintf(out_file,
76	"//************************************************************\n"
77	"// The list of bonds\n"
78	"//************************************************************\n"
79	"\n"
80	"\n");
81
82	make_bonds(the_coords, n_atoms);
83
84	current_bond = bl_head->next;
85
86	while(current_bond != NULL){
87
88	skip_bond = 0;
89
90	i = current_bond->the_bond.i;
91	j = current_bond->the_bond.j;
92
93	if(!d_hydrogens){
94
95	test1 = !strcmp("H", the_coords[i].name);
96	test2 = !strcmp("H", the_coords[j].name);
97
98	skip_bond = (test1 \|\| test2);
99	}
100
101	if(!skip_bond){
102
103	dx = (the_coords[j].x - the_coords[i].x) / 2.0;
104	dy = (the_coords[j].y - the_coords[i].y) / 2.0;
105	dz = (the_coords[j].z - the_coords[i].z) / 2.0;
106
107	fprintf(out_file,
108	"make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
109	the_coords[i].name,
110	the_coords[i].x,
111	the_coords[i].z,
112	the_coords[i].y,
113	(the_coords[i].x + dx),
114	(the_coords[i].z + dz),
115	(the_coords[i].y + dy));
116
117	fprintf(out_file,
118	"make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
119	the_coords[j].name,
120	the_coords[j].x,
121	the_coords[j].z,
122	the_coords[j].y,
123	(the_coords[j].x - dx),
124	(the_coords[j].z - dz),
125	(the_coords[j].y - dy));
126
127	fprintf(out_file, "\n");
128	}
129
130	current_bond = current_bond->next;
131	}
132
133	clean_bonds();
134	}
135	}
136
137
138	void make_bonds(struct coords *the_coords, int n_atoms){
139
140	int i, j; /counters /
141	struct linked_bond_list temp_bond; /bond place holder */
142
143	const double bond_fudge = 1.12; // a fudge factor
144	struct atom type_i, type_j; /* holds the atom types */
145
146	int test; /* booleans */
147	double dx, dy, dz, dr2, dcv, dcv2; // used to determine bond existence
148
149
150	bl_head = (struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
151	bl_head->next = NULL;
152
153	for(i = 0; i < (n_atoms - 1); i++){
154
155	for(j = (i+1); j < n_atoms; j++){
156
157	dx = the_coords[j].x - the_coords[i].x;
158	dy = the_coords[j].y - the_coords[i].y;
159	dz = the_coords[j].z - the_coords[i].z;
160
161	dr2 = dx * dx + dy * dy + dz * dz;
162
163	test = !findAtomType(the_coords[i].name, &type_i);
164	if(test){
165	fprintf(stderr, "Atom Type %s, not found!\n",
166	the_coords[i].name);
167	exit(8);
168	}
169
170	test = !findAtomType(the_coords[j].name, &type_j);
171	if(test){
172	fprintf(stderr, "Atom Type %s, not found!\n",
173	the_coords[j].name);
174	exit(8);
175	}
176
177
178	dcv = bond_fudge * (type_i.covalentRadii + type_j.covalentRadii);
179	dcv2 = dcv * dcv;
180
181	if(dr2 <= dcv2){
182
183	temp_bond =
184	(struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
185
186	bl_head->the_bond.i = i;
187	bl_head->the_bond.j = j;
188
189	temp_bond->next = bl_head;
190	bl_head = temp_bond;
191	}
192	}
193	}
194	}
195
196
197	void clean_bonds(){
198	struct linked_bond_list *current_bond;
199	struct linked_bond_list next_bond; / place holders */
200
201
202	current_bond = bl_head->next;
203
204	while(current_bond != NULL){
205
206	next_bond = current_bond->next;
207	free(current_bond);
208	current_bond = next_bond;
209	}
210
211	bl_head->next = NULL;
212	}
213
214
215	void make_header_macros(FILE *out_file){
216
217	struct linked_atom *type_list; // list of all atom types
218	struct linked_atom *current_type; // current atom type
219
220	char *name;
221	double red, green, blue;
222	double radius;
223
224	type_list = get_type_list();
225	current_type = type_list->next;
226
227	while(current_type != NULL){
228
229	name = current_type->myAtom.name;
230	radius = current_type->myAtom.vanDerWallRadii;
231	red = ((double)current_type->myAtom.red) / 255.0;
232	green = ((double)current_type->myAtom.green) / 255.0;
233	blue = ((double)current_type->myAtom.blue) / 255.0;
234
235
236
237	fprintf(out_file,
238	"//****************************************************\n"
239	"// DEFINE %s MACROS\n"
240	"//****************************************************\n"
241	"\n"
242	"#macro make_%s_bond "
243	"(end_1x, end_1y, end_1z, end_2x, end_2y, end_2z)\n"
244	"\n"
245	" #local x1 = end_1x;\n"
246	" #local y1 = end_1y;\n"
247	" #local z1 = end_1z;\n"
248	" #local x2 = end_2x;\n"
249	" #local y2 = end_2y;\n"
250	" #local z2 = end_2z;\n"
251	"\n"
252	" #if(ROTATE)\n"
253	" #local x1_new = A11 * x1 + A12 * y1 + A13 * z1;\n"
254	" #local y1_new = A21 * x1 + A22 * y1 + A23 * z1;\n"
255	" #local z1_new = A31 * x1 + A32 * y1 + A33 * z1;\n"
256	"\n"
257	" #local x2_new = A11 * x2 + A12 * y2 + A13 * z2;\n"
258	" #local y2_new = A21 * x2 + A22 * y2 + A23 * z2;\n"
259	" #local z2_new = A31 * x2 + A32 * y2 + A33 * z2;\n"
260	"\n"
261	" #else\n"
262	" #local x1_new = x1;"
263	" #local y1_new = y1;"
264	" #local z1_new = z1;"
265	"\n"
266	" #local x2_new = x2;"
267	" #local y2_new = y2;"
268	" #local z2_new = z2;"
269	"\n"
270	" #end\n"
271	"\n"
272	" cylinder{\n"
273	" < x1_new, y1_new, z1_new >,\n"
274	" < x2_new, y2_new, z2_new >,\n"
275	" BOND_RADIUS\n"
276	" texture{\n"
277	" pigment{ rgb < %lf, %lf, %lf > }\n"
278	" finish{\n"
279	" ambient .2\n"
280	" diffuse .6\n"
281	" specular 1\n"
282	" roughness .001\n"
283	" metallic\n"
284	" }\n"
285	" }\n"
286	" }\n"
287	"#end\n"
288	"#macro make_%s_atom "
289	"(center_x, center_y, center_z)\n"
290	"\n"
291	" #local x1 = center_x;\n"
292	" #local y1 = center_y;\n"
293	" #local z1 = center_z;\n"
294	"\n"
295	" #if(ROTATE)\n"
296	"\n"
297	" #local x1_new = A11 * x1 + A12 * y1 + A13 * z1;\n"
298	" #local y1_new = A21 * x1 + A22 * y1 + A23 * z1;\n"
299	" #local z1_new = A31 * x1 + A32 * y1 + A33 * z1;\n"
300	"\n"
301	" #else\n"
302	"\n"
303	" #local x1_new = x1;"
304	" #local y1_new = y1;"
305	" #local z1_new = z1;"
306	"\n"
307	" #end\n"
308	"\n"
309	" sphere{\n"
310	" < x1_new, y1_new, z1_new >,\n"
311	" ATOM_SPHERE_FACTOR * %lf\n"
312	" texture{\n"
313	" pigment{ rgb < %lf, %lf, %lf > }\n"
314	" finish{\n"
315	" ambient .2\n"
316	" diffuse .6\n"
317	" specular 1\n"
318	" roughness .001\n"
319	" metallic\n"
320	" }\n"
321	" }\n"
322	" }\n"
323	"#end\n"
324	"\n"
325	"\n",
326	name,
327	name,
328	red, green, blue,
329	name,
330	radius,
331	red, green, blue);
332
333	current_type = current_type->next;
334	}
335	}