setup examples and clean codebase
This commit is contained in:
PedroEdiaz
92
example/basic.c
Normal file
92
example/basic.c
Normal file
@@ -0,0 +1,92 @@
|
|||||||
|
#include <math.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#define KLEIN_IMPLEMENT
|
||||||
|
#include <klein/klein.h>
|
||||||
|
#include <klein/norm.h>
|
||||||
|
#include <klein/parm.h>
|
||||||
|
|
||||||
|
#ifndef M_PI
|
||||||
|
#define M_PI 3.14159265358979323846
|
||||||
|
#endif
|
||||||
|
|
||||||
|
void cube(float *d_surface, int *coord, unsigned char *grid)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < 4; i++)
|
||||||
|
d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
|
||||||
|
|
||||||
|
if (4 == 2)
|
||||||
|
d_surface[2] = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void mobius(float *d_surface, int *coord, unsigned char *grid)
|
||||||
|
{
|
||||||
|
const float width = 0.5;
|
||||||
|
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
||||||
|
float v = (2 * width) * ((float)coord[1] / grid[1]) - width;
|
||||||
|
|
||||||
|
d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
|
||||||
|
d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
|
||||||
|
d_surface[2] = v * sin(u / 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
void torus(float *d_surface, int *coord, unsigned char *grid)
|
||||||
|
{
|
||||||
|
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
||||||
|
float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
|
||||||
|
|
||||||
|
d_surface[0] = (1 + 0.5 * cos(v)) * cos(u);
|
||||||
|
d_surface[1] = (1 + 0.5 * cos(v)) * sin(u);
|
||||||
|
d_surface[2] = 0.5 * sin(v);
|
||||||
|
}
|
||||||
|
|
||||||
|
void klein(float *d_surface, int *coord, unsigned char *grid)
|
||||||
|
{
|
||||||
|
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
||||||
|
float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
|
||||||
|
|
||||||
|
d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
|
||||||
|
d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
|
||||||
|
d_surface[2] = sin(v) * cos(u / 2);
|
||||||
|
d_surface[3] = sin(v) * sin(u / 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(void)
|
||||||
|
{
|
||||||
|
unsigned char i = 0;
|
||||||
|
const char *file_name[] = {"mobius.klein", "torus.klein", "klein.klein"};
|
||||||
|
struct parm parametrization[] = {{
|
||||||
|
.grid = (unsigned char[]){16, 4},
|
||||||
|
.m = 2,
|
||||||
|
.n = 3,
|
||||||
|
.f = mobius,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
.grid = (unsigned char[]){16, 8},
|
||||||
|
.m = 2,
|
||||||
|
.n = 3,
|
||||||
|
.f = torus,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
.grid = (unsigned char[]){16, 16},
|
||||||
|
.m = 2,
|
||||||
|
.n = 4,
|
||||||
|
.f = klein,
|
||||||
|
}};
|
||||||
|
|
||||||
|
for (i = 0; i < 3; ++i)
|
||||||
|
{
|
||||||
|
struct klein klein;
|
||||||
|
printf("writing %s\n", file_name[i]);
|
||||||
|
|
||||||
|
klein_parametrize(&klein, parametrization[i]);
|
||||||
|
klein_normalize(&klein);
|
||||||
|
klein_export_file(klein, file_name[i]);
|
||||||
|
|
||||||
|
free(klein.vertex);
|
||||||
|
free(klein.normals);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
50
example/n-cube.c
Normal file
50
example/n-cube.c
Normal file
@@ -0,0 +1,50 @@
|
|||||||
|
#include <math.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#define KLEIN_IMPLEMENT
|
||||||
|
#include <klein/klein.h>
|
||||||
|
#include <klein/norm.h>
|
||||||
|
#include <klein/parm.h>
|
||||||
|
|
||||||
|
#ifndef M_PI
|
||||||
|
#define M_PI 3.14159265358979323846
|
||||||
|
#endif
|
||||||
|
|
||||||
|
unsigned char dim = 4;
|
||||||
|
|
||||||
|
void cube(float *d_surface, int *coord, unsigned char *grid)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < dim; i++)
|
||||||
|
d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
|
||||||
|
|
||||||
|
if (dim == 2)
|
||||||
|
d_surface[2] = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(void)
|
||||||
|
{
|
||||||
|
unsigned char i;
|
||||||
|
char file_name[0xff];
|
||||||
|
struct klein klein;
|
||||||
|
struct parm parametrization = {
|
||||||
|
.m = dim,
|
||||||
|
.n = dim,
|
||||||
|
.f = cube,
|
||||||
|
};
|
||||||
|
|
||||||
|
parametrization.grid = malloc(dim);
|
||||||
|
|
||||||
|
for (i = 0; i < dim; ++i)
|
||||||
|
parametrization.grid[i] = 1 << i;
|
||||||
|
|
||||||
|
snprintf(file_name, 0xff, "%03d-cube.klein", dim);
|
||||||
|
printf("writing %s\n", file_name);
|
||||||
|
|
||||||
|
klein_parametrize(&klein, parametrization);
|
||||||
|
klein_normalize(&klein);
|
||||||
|
klein_export_file(klein, file_name);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
50
example/riemman.c
Normal file
50
example/riemman.c
Normal file
@@ -0,0 +1,50 @@
|
|||||||
|
#include <complex.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#define KLEIN_IMPLEMENT
|
||||||
|
#include <klein/klein.h>
|
||||||
|
#include <klein/norm.h>
|
||||||
|
#include <klein/parm.h>
|
||||||
|
|
||||||
|
#ifndef CMPLX
|
||||||
|
#define CMPLX(a, b) (a + I * b)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
complex float f(complex float z) { return csqrt(z); }
|
||||||
|
|
||||||
|
void riemman(float *d_surface, int *coords, unsigned char *grid)
|
||||||
|
{
|
||||||
|
complex float eq;
|
||||||
|
float u = 2 * ((float)coords[0] / grid[0]) - 1;
|
||||||
|
float v = 2 * ((float)coords[1] / grid[1]) - 1;
|
||||||
|
|
||||||
|
eq = f(CMPLX(u, v));
|
||||||
|
|
||||||
|
d_surface[0] = u;
|
||||||
|
d_surface[1] = v;
|
||||||
|
d_surface[2] = creal(eq);
|
||||||
|
d_surface[3] = cimag(eq);
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(void)
|
||||||
|
{
|
||||||
|
const char *file_name = "riemman.klein";
|
||||||
|
struct klein klein;
|
||||||
|
struct parm parametrization = {
|
||||||
|
.grid = (unsigned char[]){16, 4},
|
||||||
|
.m = 2,
|
||||||
|
.n = 4,
|
||||||
|
.f = riemman,
|
||||||
|
};
|
||||||
|
|
||||||
|
printf("writing %s\n", file_name);
|
||||||
|
|
||||||
|
klein_parametrize(&klein, parametrization);
|
||||||
|
klein_normalize(&klein);
|
||||||
|
klein_export_file(klein, file_name);
|
||||||
|
|
||||||
|
free(klein.vertex);
|
||||||
|
free(klein.normals);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
48
include/klein/klein.h
Normal file
48
include/klein/klein.h
Normal file
@@ -0,0 +1,48 @@
|
|||||||
|
#ifdef KLEIN_H
|
||||||
|
#error file included twice
|
||||||
|
#endif
|
||||||
|
#define KLEIN_H
|
||||||
|
|
||||||
|
#ifdef KLEIN_IMPLEMENT
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
struct klein
|
||||||
|
{
|
||||||
|
unsigned long vertex_size;
|
||||||
|
float *vertex, *normals;
|
||||||
|
unsigned char dim;
|
||||||
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
The klein format must have:
|
||||||
|
5 bytes with klein.
|
||||||
|
1 byte empty for expantions
|
||||||
|
1 byte with the dimention of the surface
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
static inline
|
||||||
|
int klein_export_file(struct klein klein, const char * filename);
|
||||||
|
|
||||||
|
|
||||||
|
#ifdef KLEIN_IMPLEMENT
|
||||||
|
static inline
|
||||||
|
int klein_export_file(struct klein klein, const char * filename)
|
||||||
|
{
|
||||||
|
FILE *file = fopen(filename, "wb");
|
||||||
|
if (!file)
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
fwrite("KLEIN", 1, 5, file);
|
||||||
|
fwrite("\0", 1, 1, file);
|
||||||
|
fwrite(&klein.dim, 1, 1, file);
|
||||||
|
fwrite(&klein.vertex_size, 8, 1, file);
|
||||||
|
fwrite(klein.vertex, 16, klein.vertex_size * klein.dim, file);
|
||||||
|
fwrite(klein.normals, 16, klein.vertex_size * klein.dim, file);
|
||||||
|
|
||||||
|
fclose(file);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
118
include/klein/norm.h
Normal file
118
include/klein/norm.h
Normal file
@@ -0,0 +1,118 @@
|
|||||||
|
static inline
|
||||||
|
void __calculate_normal( float *p1, float *p2, float *p3, float *normal, unsigned char n)
|
||||||
|
{ unsigned char i;
|
||||||
|
float alpha;
|
||||||
|
float *v1, *v2, *v3;
|
||||||
|
float *u1, *u2, *u3;
|
||||||
|
|
||||||
|
v1 = malloc(n * sizeof(float));
|
||||||
|
v2 = malloc(n * sizeof(float));
|
||||||
|
v3 = malloc(n * sizeof(float));
|
||||||
|
u1 = malloc(n * sizeof(float));
|
||||||
|
u2 = malloc(n * sizeof(float));
|
||||||
|
u3 = malloc(n * sizeof(float));
|
||||||
|
|
||||||
|
/*
|
||||||
|
Calculate a normal vector of a plain using Gram-Schmidt process
|
||||||
|
*/
|
||||||
|
{
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
v1[i] = p2[i] - p1[i];
|
||||||
|
v2[i] = p3[i] - p1[i];
|
||||||
|
v3[i] = p1[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
u1[i] = v1[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
{
|
||||||
|
float proj[n];
|
||||||
|
float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
dot_v2_u1 += v2[i] * u1[i];
|
||||||
|
dot_u1_u1 += u1[i] * u1[i];
|
||||||
|
}
|
||||||
|
alpha = dot_v2_u1 / dot_u1_u1;
|
||||||
|
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
proj[i] = u1[i] * alpha;
|
||||||
|
u2[i] = v2[i] - proj[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
{
|
||||||
|
float proj1[n], proj2[n];
|
||||||
|
float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
|
||||||
|
float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
|
||||||
|
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
dot_v3_u1 += v3[i] * u1[i];
|
||||||
|
dot_u1_u1 += u1[i] * u1[i];
|
||||||
|
}
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
dot_v3_u2 += v3[i] * u2[i];
|
||||||
|
dot_u2_u2 += u2[i] * u2[i];
|
||||||
|
}
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
|
||||||
|
u3[i] = v3[i] - proj1[i] - proj2[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
float magnitude = 0.0f;
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
magnitude += u3[i] * u3[i];
|
||||||
|
}
|
||||||
|
magnitude = sqrtf(magnitude);
|
||||||
|
|
||||||
|
for (i = 0; i < n; ++i)
|
||||||
|
{
|
||||||
|
normal[i] = u3[i] / magnitude;
|
||||||
|
}
|
||||||
|
|
||||||
|
free(v1);
|
||||||
|
free(v2);
|
||||||
|
free(v3);
|
||||||
|
free(u1);
|
||||||
|
free(u2);
|
||||||
|
free(u3);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void klein_normalize(struct klein * klein)
|
||||||
|
{
|
||||||
|
unsigned long i;
|
||||||
|
unsigned char j;
|
||||||
|
float *norm_vec;
|
||||||
|
|
||||||
|
klein->normals = malloc((klein->dim * klein->vertex_size) * sizeof(float));
|
||||||
|
norm_vec = malloc(klein->dim * sizeof(float));
|
||||||
|
|
||||||
|
for (i = 0; i < klein->vertex_size; i += 3 * klein->dim)
|
||||||
|
{
|
||||||
|
__calculate_normal(klein->vertex + i, klein->vertex + i + klein->dim, klein->vertex + i + 2 * klein->dim, norm_vec, klein->dim);
|
||||||
|
for (j = 0; j < klein->dim; ++j )
|
||||||
|
{
|
||||||
|
(klein->normals + i)[j]=norm_vec[j];
|
||||||
|
(klein->normals + i + klein->dim)[j]=norm_vec[j];
|
||||||
|
(klein->normals + i + 2*klein->dim)[j]=norm_vec[j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
free(norm_vec);
|
||||||
|
}
|
||||||
134
include/klein/parm.h
Normal file
134
include/klein/parm.h
Normal file
@@ -0,0 +1,134 @@
|
|||||||
|
#ifndef KLEIN_H
|
||||||
|
#warning Please include klein/klein.h before klein/parm.h
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef KLEIN_PARM_H
|
||||||
|
#error file included twice
|
||||||
|
#endif
|
||||||
|
#define KLEIN_PARM_H
|
||||||
|
|
||||||
|
|
||||||
|
typedef void (*function_t)(float *, int *, unsigned char *);
|
||||||
|
|
||||||
|
struct parm
|
||||||
|
{
|
||||||
|
unsigned char *grid;
|
||||||
|
unsigned char m, n;
|
||||||
|
function_t f;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
void klein_parametrize( struct klein * klein, struct parm parm );
|
||||||
|
|
||||||
|
#ifdef KLEIN_IMPLEMENT
|
||||||
|
#ifdef TEST
|
||||||
|
#include <assert.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
static inline int __factorial(int n)
|
||||||
|
{
|
||||||
|
if (n == 1)
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
return n * __factorial(n - 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline int __face(int n)
|
||||||
|
{
|
||||||
|
if (n == 2)
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
return (1 << (n - 3)) * __factorial(n) / __factorial(n - 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
void klein_parametrize( struct klein * klein, struct parm parm)
|
||||||
|
{
|
||||||
|
unsigned int i, j, k, o, p, n;
|
||||||
|
unsigned long size, q = 0;
|
||||||
|
int *face;
|
||||||
|
|
||||||
|
#ifdef TEST
|
||||||
|
assert(__face(2) == 1);
|
||||||
|
assert(__face(3) == 6);
|
||||||
|
assert(__face(4) == 24);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
klein->dim = parm.n;
|
||||||
|
klein->vertex_size = 0;
|
||||||
|
{
|
||||||
|
unsigned char test = 0;
|
||||||
|
for (o = 0; o < parm.m; o++)
|
||||||
|
{
|
||||||
|
for (p = 0; p < o; p++)
|
||||||
|
{
|
||||||
|
test += 1;
|
||||||
|
klein->vertex_size += parm.grid[p] * parm.grid[o] * 6 * __face(parm.m);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
klein->vertex_size /= test;
|
||||||
|
}
|
||||||
|
|
||||||
|
size = (klein->dim) * (klein->vertex_size);
|
||||||
|
klein->vertex = malloc(size * sizeof(float));
|
||||||
|
|
||||||
|
face = malloc(parm.m * sizeof(int));
|
||||||
|
|
||||||
|
for (o = 0; o < parm.m; o++)
|
||||||
|
{
|
||||||
|
for (p = 0; p < o; p++)
|
||||||
|
{
|
||||||
|
for (k = 0; k < (1 << (parm.m - 2)); k++)
|
||||||
|
{
|
||||||
|
unsigned char skip = 0;
|
||||||
|
for (n = 0; n < parm.m; n++)
|
||||||
|
{
|
||||||
|
if (n == o || n == p)
|
||||||
|
skip++;
|
||||||
|
|
||||||
|
face[n] = (k & (1 << (n - skip))) ? parm.grid[n] : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < parm.grid[p]; i++)
|
||||||
|
{
|
||||||
|
for (j = 0; j < parm.grid[o]; j++)
|
||||||
|
{
|
||||||
|
face[p] = i;
|
||||||
|
face[o] = j;
|
||||||
|
parm.f(&klein->vertex[q], face, parm.grid);
|
||||||
|
q += parm.n;
|
||||||
|
|
||||||
|
face[p] = i + 1;
|
||||||
|
face[o] = j;
|
||||||
|
parm.f(&klein->vertex[q], face, parm.grid);
|
||||||
|
q += parm.n;
|
||||||
|
|
||||||
|
face[p] = i + 1;
|
||||||
|
face[o] = j + 1;
|
||||||
|
parm.f(&klein->vertex[q], face, parm.grid);
|
||||||
|
q += parm.n;
|
||||||
|
|
||||||
|
face[p] = i;
|
||||||
|
face[o] = j;
|
||||||
|
parm.f(&klein->vertex[q], face, parm.grid);
|
||||||
|
q += parm.n;
|
||||||
|
|
||||||
|
face[p] = i;
|
||||||
|
face[o] = j + 1;
|
||||||
|
parm.f(&klein->vertex[q], face, parm.grid);
|
||||||
|
q += parm.n;
|
||||||
|
|
||||||
|
face[p] = i + 1;
|
||||||
|
face[o] = j + 1;
|
||||||
|
parm.f(&klein->vertex[q], face, parm.grid);
|
||||||
|
q += parm.n;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef TEST
|
||||||
|
assert(q == size);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
#endif
|
||||||
@@ -1,40 +0,0 @@
|
|||||||
#undef A
|
|
||||||
#undef B
|
|
||||||
#undef C
|
|
||||||
#undef D
|
|
||||||
#undef E
|
|
||||||
#undef F
|
|
||||||
#undef G
|
|
||||||
#undef H
|
|
||||||
|
|
||||||
#define A -2.0,-0.05,-0.05,
|
|
||||||
#define B -2.0,-0.05, 0.05,
|
|
||||||
#define C -2.0, 0.05,-0.05,
|
|
||||||
#define D -2.0, 0.05, 0.05,
|
|
||||||
#define E 2.0,-0.05,-0.05,
|
|
||||||
#define F 2.0,-0.05, 0.05,
|
|
||||||
#define G 2.0, 0.05,-0.05,
|
|
||||||
#define H 2.0, 0.05, 0.05,
|
|
||||||
|
|
||||||
float d_axis[] =
|
|
||||||
{
|
|
||||||
3*3*2*6,
|
|
||||||
|
|
||||||
A C E
|
|
||||||
G E C
|
|
||||||
|
|
||||||
E G F
|
|
||||||
H F G
|
|
||||||
|
|
||||||
F H B
|
|
||||||
D B H
|
|
||||||
|
|
||||||
B D A
|
|
||||||
C A D
|
|
||||||
|
|
||||||
C D G
|
|
||||||
H G D
|
|
||||||
|
|
||||||
E B A
|
|
||||||
B E F
|
|
||||||
};
|
|
||||||
32
src/klein.c
32
src/klein.c
@@ -2,29 +2,43 @@
|
|||||||
|
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
|
|
||||||
int create_surface_klein( unsigned char * path, struct surface * surface )
|
/*
|
||||||
|
KLEIN Format:
|
||||||
|
5 bytes with KLEIN
|
||||||
|
1 byte empty for scaling
|
||||||
|
1 byte with the dimention of the surface
|
||||||
|
8 bytes interprated as a long with the number of vertex
|
||||||
|
n bytes with the vertex data of the surface
|
||||||
|
n bytes with the normal data of the surface
|
||||||
|
|
||||||
|
where n is the size of the vertex and normal data that could be
|
||||||
|
calculated as the dimention of the surface time the number of vertes
|
||||||
|
time the size of a 16 bytes float.
|
||||||
|
*/
|
||||||
|
|
||||||
|
int create_surface_klein(unsigned char *path, struct surface *surface)
|
||||||
{
|
{
|
||||||
unsigned long size;
|
unsigned long size;
|
||||||
char buffer[5];
|
char buffer[5];
|
||||||
FILE * file = fopen(path, "rb" );
|
FILE *file = fopen(path, "rb");
|
||||||
if( !file )
|
if (!file)
|
||||||
return 1;
|
return 1;
|
||||||
|
|
||||||
fread(buffer, 1, 5, file );
|
fread(buffer, 1, 5, file);
|
||||||
|
|
||||||
if( strncmp(buffer, "KLEIN", 5 ) )
|
if (strncmp(buffer, "KLEIN", 5))
|
||||||
return 1;
|
return 1;
|
||||||
|
|
||||||
fread(buffer, 1, 1, file );
|
fread(buffer, 1, 1, file);
|
||||||
fread(&surface->dim, 1, 1, file);
|
fread(&surface->dim, 1, 1, file);
|
||||||
fread(&surface->vertex, 8, 1, file);
|
fread(&surface->vertex, 8, 1, file);
|
||||||
|
|
||||||
size = surface->dim * surface->vertex;
|
size = surface->dim * surface->vertex;
|
||||||
|
|
||||||
surface->data=malloc(16*size );
|
surface->data = malloc(16 * size);
|
||||||
fread(surface->data, 16,size, file);
|
fread(surface->data, 16, size, file);
|
||||||
|
|
||||||
surface->norm=malloc(16*size );
|
surface->norm = malloc(16 * size);
|
||||||
fread(surface->norm, 16, size, file);
|
fread(surface->norm, 16, size, file);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|||||||
388
src/surface.c
388
src/surface.c
@@ -1,388 +0,0 @@
|
|||||||
#include <complex.h>
|
|
||||||
#include <math.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#define TEST
|
|
||||||
|
|
||||||
#define CGLM_ALL_UNALIGNED
|
|
||||||
#include <cglm/vec3.h>
|
|
||||||
#include <cglm/vec4.h>
|
|
||||||
|
|
||||||
#ifndef M_PI
|
|
||||||
#define M_PI 3.14159265358979323846
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef CMPLX
|
|
||||||
#define CMPLX(a, b) (a + I * b)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef TEST
|
|
||||||
#include <assert.h>
|
|
||||||
#endif
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
typedef void (*function_t)(float *, int *, unsigned char *);
|
|
||||||
|
|
||||||
struct parm
|
|
||||||
{
|
|
||||||
unsigned char *grid;
|
|
||||||
unsigned char m, n;
|
|
||||||
function_t f;
|
|
||||||
};
|
|
||||||
|
|
||||||
// Función para escribir el archivo .klein
|
|
||||||
int write_klein_file(const char *filename, unsigned char dim, unsigned long vertex, float *vertices, float *normals)
|
|
||||||
{
|
|
||||||
FILE *file = fopen(filename, "wb");
|
|
||||||
if (!file)
|
|
||||||
{
|
|
||||||
perror("Error al abrir el archivo");
|
|
||||||
exit(EXIT_FAILURE);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Escribir encabezado
|
|
||||||
fwrite("KLEIN", 1, 5, file); // Los primeros 5 bytes son "KLEIN"
|
|
||||||
fputc(0, file); // Byte vacío
|
|
||||||
fwrite(&dim, 1, 1, file); // Dimensión de la superficie
|
|
||||||
fwrite(&vertex, sizeof(unsigned long), 1, file); // Número de vértices (8 bytes)
|
|
||||||
fwrite(vertices, sizeof(float), vertex * dim, file);
|
|
||||||
fwrite(normals, sizeof(float), vertex * dim, file);
|
|
||||||
printf("Archivo %s escrito correctamente.\n", filename);
|
|
||||||
|
|
||||||
fclose(file);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int factorial(int n)
|
|
||||||
{
|
|
||||||
if (n == 1)
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
return n * factorial(n - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
int faces(int n)
|
|
||||||
{
|
|
||||||
if (n == 2)
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
return (1 << (n - 3)) * factorial(n) / factorial(n - 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
void riemman(float *d_surface, int *coords, unsigned char *grid)
|
|
||||||
{
|
|
||||||
complex double eq;
|
|
||||||
float u = 2 * ((float)coords[0] / grid[0]) - 1;
|
|
||||||
float v = 2 * ((float)coords[1] / grid[1]) - 1;
|
|
||||||
|
|
||||||
eq = csqrt(CMPLX(u, v));
|
|
||||||
|
|
||||||
d_surface[0] = u;
|
|
||||||
d_surface[1] = v;
|
|
||||||
d_surface[2] = creal(eq);
|
|
||||||
d_surface[3] = cimag(eq);
|
|
||||||
}
|
|
||||||
|
|
||||||
void cube(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < 4; i++)
|
|
||||||
d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
|
|
||||||
|
|
||||||
if (4 == 2)
|
|
||||||
d_surface[2] = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
void mobius(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
const float width = 0.5;
|
|
||||||
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
|
||||||
float v = (2 * width) * ((float)coord[1] / grid[1]) - width;
|
|
||||||
|
|
||||||
d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
|
|
||||||
d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
|
|
||||||
d_surface[2] = v * sin(u / 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
void torus(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
|
||||||
float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
|
|
||||||
|
|
||||||
d_surface[0] = (1 + 0.5 * cos(v)) * cos(u);
|
|
||||||
d_surface[1] = (1 + 0.5 * cos(v)) * sin(u);
|
|
||||||
d_surface[2] = 0.5 * sin(v);
|
|
||||||
}
|
|
||||||
|
|
||||||
void klein(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
|
||||||
float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
|
|
||||||
|
|
||||||
d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
|
|
||||||
d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
|
|
||||||
d_surface[2] = sin(v) * cos(u / 2);
|
|
||||||
d_surface[3] = sin(v) * sin(u / 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
float *generate_data_surface(unsigned char *dim, unsigned long *vertex, struct parm *parm)
|
|
||||||
{
|
|
||||||
unsigned int i, j, k, o, p, n;
|
|
||||||
unsigned long size, q = 0;
|
|
||||||
float *d_surface;
|
|
||||||
int *cara;
|
|
||||||
|
|
||||||
parm->f = cube;
|
|
||||||
parm->m = 4;
|
|
||||||
parm->n = 4;
|
|
||||||
parm->grid = (unsigned char[]){16, 8, 4, 2, 1};
|
|
||||||
|
|
||||||
#ifdef TEST
|
|
||||||
assert(faces(2) == 1);
|
|
||||||
assert(faces(3) == 6);
|
|
||||||
assert(faces(4) == 24);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
*dim = parm->n;
|
|
||||||
*vertex = 0;
|
|
||||||
|
|
||||||
{
|
|
||||||
unsigned char test = 0;
|
|
||||||
for (o = 0; o < parm->m; o++)
|
|
||||||
{
|
|
||||||
for (p = 0; p < o; p++)
|
|
||||||
{
|
|
||||||
test += 1;
|
|
||||||
*vertex += parm->grid[p] * parm->grid[o] * 6 * faces(parm->n);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
*vertex /= test;
|
|
||||||
}
|
|
||||||
|
|
||||||
cara = malloc(parm->m * sizeof(int));
|
|
||||||
size = (*dim) * (*vertex);
|
|
||||||
d_surface = malloc(size * sizeof(float));
|
|
||||||
|
|
||||||
for (o = 0; o < parm->m; o++)
|
|
||||||
{
|
|
||||||
for (p = 0; p < o; p++)
|
|
||||||
{
|
|
||||||
for (k = 0; k < (1 << (parm->m - 2)); k++)
|
|
||||||
{
|
|
||||||
unsigned char skip = 0;
|
|
||||||
for (n = 0; n < parm->m; n++)
|
|
||||||
{
|
|
||||||
if (n == o || n == p)
|
|
||||||
skip++;
|
|
||||||
|
|
||||||
cara[n] = (k & (1 << (n - skip))) ? parm->grid[n] : 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < parm->grid[p]; i++)
|
|
||||||
{
|
|
||||||
for (j = 0; j < parm->grid[o]; j++)
|
|
||||||
{
|
|
||||||
cara[p] = i;
|
|
||||||
cara[o] = j;
|
|
||||||
parm->f(&d_surface[q], cara, parm->grid);
|
|
||||||
q += parm->n;
|
|
||||||
|
|
||||||
cara[p] = i + 1;
|
|
||||||
cara[o] = j;
|
|
||||||
parm->f(&d_surface[q], cara, parm->grid);
|
|
||||||
q += parm->n;
|
|
||||||
|
|
||||||
cara[p] = i + 1;
|
|
||||||
cara[o] = j + 1;
|
|
||||||
parm->f(&d_surface[q], cara, parm->grid);
|
|
||||||
q += parm->n;
|
|
||||||
|
|
||||||
cara[p] = i;
|
|
||||||
cara[o] = j;
|
|
||||||
parm->f(&d_surface[q], cara, parm->grid);
|
|
||||||
q += parm->n;
|
|
||||||
|
|
||||||
cara[p] = i;
|
|
||||||
cara[o] = j + 1;
|
|
||||||
parm->f(&d_surface[q], cara, parm->grid);
|
|
||||||
q += parm->n;
|
|
||||||
|
|
||||||
cara[p] = i + 1;
|
|
||||||
cara[o] = j + 1;
|
|
||||||
parm->f(&d_surface[q], cara, parm->grid);
|
|
||||||
q += parm->n;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef TEST
|
|
||||||
assert(q == size);
|
|
||||||
#endif
|
|
||||||
return d_surface;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void __calculate_normal(
|
|
||||||
float *p1, float *p2, float *p3, float *normal, unsigned char n)
|
|
||||||
{
|
|
||||||
unsigned char i;
|
|
||||||
float alpha;
|
|
||||||
float *v1, *v2, *v3;
|
|
||||||
float *u1, *u2, *u3;
|
|
||||||
|
|
||||||
v1 = malloc(n * sizeof(float));
|
|
||||||
v2 = malloc(n * sizeof(float));
|
|
||||||
v3 = malloc(n * sizeof(float));
|
|
||||||
u1 = malloc(n * sizeof(float));
|
|
||||||
u2 = malloc(n * sizeof(float));
|
|
||||||
u3 = malloc(n * sizeof(float));
|
|
||||||
|
|
||||||
/*
|
|
||||||
Calculate a normal vector of a plain using Gram-Schmidt process
|
|
||||||
*/
|
|
||||||
{
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
v1[i] = p2[i] - p1[i];
|
|
||||||
v2[i] = p3[i] - p1[i];
|
|
||||||
v3[i] = p1[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
u1[i] = v1[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
float proj[n];
|
|
||||||
float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
dot_v2_u1 += v2[i] * u1[i];
|
|
||||||
dot_u1_u1 += u1[i] * u1[i];
|
|
||||||
}
|
|
||||||
alpha = dot_v2_u1 / dot_u1_u1;
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
proj[i] = u1[i] * alpha;
|
|
||||||
u2[i] = v2[i] - proj[i];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
float proj1[n], proj2[n];
|
|
||||||
float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
|
|
||||||
float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
dot_v3_u1 += v3[i] * u1[i];
|
|
||||||
dot_u1_u1 += u1[i] * u1[i];
|
|
||||||
}
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
dot_v3_u2 += v3[i] * u2[i];
|
|
||||||
dot_u2_u2 += u2[i] * u2[i];
|
|
||||||
}
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
|
|
||||||
u3[i] = v3[i] - proj1[i] - proj2[i];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
float magnitude = 0.0f;
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
magnitude += u3[i] * u3[i];
|
|
||||||
}
|
|
||||||
magnitude = sqrtf(magnitude);
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
normal[i] = u3[i] / magnitude;
|
|
||||||
}
|
|
||||||
|
|
||||||
free(v1);
|
|
||||||
free(v2);
|
|
||||||
free(v3);
|
|
||||||
free(u1);
|
|
||||||
free(u2);
|
|
||||||
free(u3);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
float *generate_normals_surface(float *d, unsigned char m, unsigned long vertex)
|
|
||||||
{
|
|
||||||
float *n;
|
|
||||||
float *norm_vec;
|
|
||||||
|
|
||||||
n = malloc((m * vertex) * sizeof(float));
|
|
||||||
|
|
||||||
norm_vec = malloc(m * sizeof(float));
|
|
||||||
|
|
||||||
for (int i = 0; i < *d; i += 3 * m)
|
|
||||||
{
|
|
||||||
|
|
||||||
__calculate_normal(d + i, d + i + m, d + i + 2 * m, norm_vec, m);
|
|
||||||
glm_vec3_copy(norm_vec, n + i);
|
|
||||||
glm_vec3_copy(norm_vec, n + i + m);
|
|
||||||
glm_vec3_copy(norm_vec, n + i + 2 * m);
|
|
||||||
}
|
|
||||||
|
|
||||||
free(norm_vec);
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
|
|
||||||
struct parm parm_instance;
|
|
||||||
parm_instance.grid = (unsigned char[]){16, 8, 4, 2, 1};
|
|
||||||
parm_instance.m = 4;
|
|
||||||
parm_instance.n = 4;
|
|
||||||
parm_instance.f = cube;
|
|
||||||
unsigned char dim;
|
|
||||||
unsigned long vertex;
|
|
||||||
float *vertices, *normals;
|
|
||||||
|
|
||||||
// Generar datos de la superficie
|
|
||||||
vertices = generate_data_surface(&dim, &vertex, &parm_instance);
|
|
||||||
|
|
||||||
// Verificar datos generados
|
|
||||||
if (vertices == NULL) {
|
|
||||||
printf("Error: vertices no generados.\n");
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
printf("Dim: %u, Vertex: %lu\n", dim, vertex);
|
|
||||||
|
|
||||||
// Generar normales
|
|
||||||
normals = generate_normals_surface(vertices, dim, vertex);
|
|
||||||
|
|
||||||
// Verificar normales generadas
|
|
||||||
if (normals == NULL) {
|
|
||||||
printf("Error: normales no generadas.\n");
|
|
||||||
free(vertices);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Escribir el archivo
|
|
||||||
printf("Escribiendo archivo .klein\n");
|
|
||||||
write_klein_file("test.klein", dim, vertex, vertices, normals);
|
|
||||||
|
|
||||||
free(vertices);
|
|
||||||
free(normals);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
Reference in New Issue
Block a user