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 initBondList(void){
  bl_head = NULL;
}

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