extern int metric_tensor(vector_t v, mt_t mt, m2_t *m2)
{
double
a[3];
bilinear_t
*B[3] = {mt.a, mt.b, mt.c};
for (int i = 0 ; i < 3 ; i++)
{
int err = bilinear(v.x, v.y, B[i], a+i);
switch (err)
{
case ERROR_OK: break;
case ERROR_NODATA:
default: return err;
}
}
M2A(*m2) = a[0];
M2B(*m2) = a[1];
M2C(*m2) = a[1];
M2D(*m2) = a[2];
return ERROR_OK;
}
extern int metric_tensor_new(bbox_t bb, int nx, int ny, mt_t *mt)
{
int err;
bilinear_t* B[4];
for (int k = 0 ; k < 4 ; k++)
{
if (!(B[k] = bilinear_new()))
return ERROR_MALLOC;
if ((err = bilinear_dimension(nx,ny,bb,B[k])) != ERROR_OK)
return err;
}
for (int i = 0 ; i < nx ; i++)
{
for (int j = 0 ; j < ny ; j++)
{
arrow_t A;
bilinear_getxy(i, j, B[0], &(A.centre.x), &(A.centre.y));
err = evaluate(&A);
switch (err)
{
ellipse_t E;
m2_t m2;
case ERROR_OK:
arrow_ellipse(&A,&E);
m2 = ellipse_mt(E);
bilinear_setz(i, j, M2A(m2), B[0]);
bilinear_setz(i, j, M2B(m2), B[1]);
bilinear_setz(i, j, M2D(m2), B[2]);
bilinear_setz(i, j, E.major*E.minor*M_PI, B[3]);
break;
case ERROR_NODATA:
break;
default:
return err;
}
}
}
mt->a = B[0];
mt->b = B[1];
mt->c = B[2];
mt->area = B[3];
return ERROR_OK;
}
/* Single threaded ramfs server. Grab a group of messages,
process each one & send response
*/
void
main()
{
Message msg;
Block req, res;
int dfd, acfd, lcfd;
char adir[40], ldir[40];
acfd = announce("tcp!*!564", adir);
if (acfd < 0)
exits("could not announce ramfs");
for (;;) {
lcfd = listen(adir, ldir);
if (lcfd < 0)
exits("could not listen");
/* accept & read incoming data */
dfd = accept(lcfd, ldir);
if (dfd < 0)
exits("could not accept");
/* read request */
fd2B(&req, dfd);
/* allocate response */
res.rdp = nil;
res.beg = (uchar*) calloc(4096, 1);
res.wrp = req.beg;
res.lim = req.beg + 4096;
/* iterate over messages & collect responses */
while (B2M(&req, &msg)) {
if (!ramfs_table[msg.code]) {
/* send rerror & process no more */
msg.code = Rerror_code;
msg.rerror.ename = Enotimpl;
M2B(&res, &msg);
break;
}
ramfs_table[msg.code](&res, &msg);
}
/* send response */
B2fd(&res, dfd);
}
}
