ISTVOID Get4Points(struct sphere_model *model)
{
ISTFLOAT dv[IST_SPHERE_DATAMAX][3];
ISTFLOAT cross[3] = {0};
ISTFLOAT tmpv[3] = {0};
ISTSHORT ndata = model->num;
ISTSHORT i, j;
ISTFLOAT dist, tmp;
// Point 0
for (j = 0; j < 3; ++j) {
model->p4s[0][j] = model->data[0][j];
}
// Point 1
dist = 0;
for (i = 1; i < ndata; i++) {
tmp = GetDistance(model->data[i], model->p4s[0]);
if (_lt(dist, tmp)) {
dist = tmp;
for (j = 0; j < 3; j++) {
model->p4s[1][j] = model->data[i][j];
}
}
}
// Point 2
dist = 0;
for (j = 0; j < 3; j++) {
dv[0][j] = _sub(model->p4s[1][j], model->p4s[0][j]);
}
for (i = 1; i < ndata; i++) {
for (j = 0; j < 3; j++) {
dv[i][j] = _sub(model->data[i][j], model->p4s[0][j]);
}
tmpv[0] = _sub(_mul(dv[0][1], dv[i][2]), _mul(dv[0][2], dv[i][1]));
tmpv[1] = _sub(_mul(dv[0][2], dv[i][0]), _mul(dv[0][0], dv[i][2]));
tmpv[2] = _sub(_mul(dv[0][0], dv[i][1]), _mul(dv[0][1], dv[i][0]));
tmp = _add3(_pow2(tmpv[0]), _pow2(tmpv[1]), _pow2(tmpv[2]));
if (_lt(dist, tmp)) {
dist = tmp;
for (j = 0; j < 3; j++) {
model->p4s[2][j] = model->data[i][j];
cross[j] = tmpv[j];
}
}
}
// Point 3
dist = 0;
for (i = 1; i < ndata; i++) {
tmp = _add3(_mul(dv[i][0], cross[0]), _mul(dv[i][1], cross[1]), _mul(dv[i][2], cross[2]));
tmp = _abs(tmp);
if (_lt(dist, tmp)) {
dist = tmp;
for (j = 0; j < 3; j++) {
model->p4s[3][j] = model->data[i][j];
}
}
}
return;
}
static
Value *
eval(const Ast *expr) {
switch(expr->class) {
case N_CALL:
return call(expr);
case N_ASSIGNMENT:
return assignment(expr);
case N_IDENTIFIER:
return identifier(expr);
case N_NEG:
return _neg(expr);
case N_NOT:
return _not(expr);
case N_EQ:
return _eq(expr);
case N_NEQ:
return _neq(expr);
case N_AND:
return _and(expr);
case N_IOR:
return _ior(expr);
case N_XOR:
return _neq(expr); // alias
case N_LT:
return _lt(expr);
case N_LE:
return _le(expr);
case N_GE:
return _ge(expr);
case N_GT:
return _gt(expr);
case N_ADD:
return _add(expr);
case N_SUB:
return _sub(expr);
case N_MUL:
return _mul(expr);
case N_DIV:
return _div(expr);
case N_POW:
return _pow(expr);
case N_MOD:
return _mod(expr);
case N_BOOLEAN:
return _bool(expr);
case N_INTEGER:
return _int(expr);
case N_FLOAT:
return _float(expr);
case N_STRING:
return _string(expr);
case N_SET:
return _set(expr);
case N_R:
return _relation(expr);
}
printf("EVALFAIL %d ", expr->class); pn(expr);
assert(false && "should not be reached");
}
ISTBOOL GetParams(struct sphere_model *model, ISTFLOAT rad)
{
ISTSHORT i, j;
ISTFLOAT min[3] = {0};
ISTFLOAT max[3] = {0};
ISTFLOAT mean[3] = {0};
ISTFLOAT var[3] = {0};
ISTFLOAT tmpf;
ISTFLOAT two = _float(2);
for (j = 0; j < 3; j++) {
min[j] = model->offsets[0][j];
max[j] = model->offsets[0][j];
for (i = 1; i < IST_SPHERE_OFFSET_NUM; i++) {
if (_lt(model->offsets[i][j], min[j])) {
min[j] = model->offsets[i][j];
}
if (_gt(model->offsets[i][j], max[j])) {
max[j] = model->offsets[i][j];
}
}
mean[j] = _div(_add(max[j], min[j]), two);
var[j] = _sub(max[j], min[j]);
}
tmpf = _mul(rad, model->ratio);
if (_ge(var[0], tmpf) || _ge(var[1], tmpf) || _ge(var[2], tmpf)) {
goto EXIT;
}
for (j = 0; j < 3; ++j) {
model->mean[j] = mean[j];
model->var[j] = var[j];
}
model->rad = rad;
return ISTTRUE;
EXIT:
return ISTFALSE;
}
/*
* TKGetNextToken returns the next token from the token stream as a
* character string. Space for the returned token should be dynamically
* allocated. The caller is responsible for freeing the space once it is
* no longer needed.
*
* If the function succeeds, it returns a C string (delimited by '\0')
* containing the token. Else it returns 0.
*
* You need to fill in this function as part of your implementation.
*/
TokenT *TKGetNextToken(TokenizerT *tk) {
clearBuffer(tk);
char curr = tk->inputIter[0];
// skip all whitespace before next token
while(isspace(curr)) {
nextChar(tk);
clearBuffer(tk);
curr = tk->inputIter[0];
}
if(curr == '\0') {
return NULL;
} else if(isalpha(curr) || curr == '_') {
return _word(tk);
} else if(curr == '0') {
return _zero(tk);
} else if(isdigit(curr)) {
return _decimal(tk);
} else if(curr == '!') { // neq
return _neq(tk);
} else if(curr == '"') { // double_quote
return _double_quote(tk);
} else if(curr == '#') {
return _pound(tk);
} else if(curr == '$') { // INVALID
return _invalid(tk);
} else if(curr == '%') { // mod, mod_eq
return _mod(tk);
} else if(curr == '&') { // bit_and, log_and, address (?)
return _bit_and(tk);
} else if(curr == '\'') { // single_quote
return _single_quote(tk);
} else if(curr == '(') { // open_paren
return _open_paren(tk);
} else if(curr == ')') { // close_paren
return _close_paren(tk);
} else if(curr == '*') { // mult, mult_eq, pointer (?)
return _mult(tk);
} else if(curr == '+') { // plus, plus_eq, inc
return _plus(tk);
} else if(curr == ',') { // comma
return _comma(tk);
} else if(curr == '-') { // minus, minus_eq, dec, struct_pointer
return _minus(tk);
} else if(curr == '.') { // dot
return _dot(tk);
} else if(curr == '/') { // div, div_eq
return _div(tk);
} else if(curr == ':') { // ternary_colon
return _ternary_colon(tk);
} else if(curr == ';') { // semicolon
return _semicolon(tk);
} else if(curr == '<') { // lt, lshift, lt_eq
return _lt(tk);
} else if(curr == '=') { // eq, assign
return _eq(tk);
} else if(curr == '>') { // gt, rshift, gt_eq
return _gt(tk);
} else if(curr == '?') { // ternary_qmark
return _ternary_qmark(tk);
} else if(curr == '@') { // INVALID
return _invalid(tk);
} else if(curr == '[') { // open_bracket
return _open_bracket(tk);
} else if(curr == '\\') { // backslash (?)
return _invalid(tk);
} else if(curr == ']') { // close_bracket
return _close_bracket(tk);
} else if(curr == '^') { // bit_xor
return _bit_xor(tk);
} else if(curr == '`') { // INVALID
return _invalid(tk);
} else if(curr == '{') { // open_brace
return _open_brace(tk);
} else if(curr == '|') { // bit_or, log_or
return _bit_or(tk);
} else if(curr == '}') { // close_brace
return _close_brace(tk);
} else if(curr == '~') { // bit_not
return _bit_not(tk);
} else {
return _invalid(tk);
}
}
ISTBOOL GetSphereFrom4Points(struct sphere_model *model)
{
ISTFLOAT a[4][4] = {{0}};
ISTFLOAT ho[3] = {0};
ISTFLOAT norm = 0;
ISTFLOAT rad = 0;
ISTFLOAT tmpf = 0;
ISTFLOAT two = _float(2);
ISTFLOAT m11, m12, m13, m14, m15;
ISTINT i, j;
// Get sphere from 4 points
for (i = 0; i < 4; i++) { /* find minor 11 */
a[i][0] = model->p4s[i][0];
a[i][1] = model->p4s[i][1];
a[i][2] = model->p4s[i][2];
a[i][3] = _one;
}
m11 = GetDet(a, 4);
for (i = 0; i < 4; i++) { /* find minor 12 */
a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
_mul(model->p4s[i][1], model->p4s[i][1])),
_mul(model->p4s[i][2], model->p4s[i][2]));
a[i][1] = model->p4s[i][1];
a[i][2] = model->p4s[i][2];
a[i][3] = _one;
}
m12 = GetDet(a, 4);
for (i = 0; i < 4; i++) { /* find minor 13 */
a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
_mul(model->p4s[i][1], model->p4s[i][1])),
_mul(model->p4s[i][2], model->p4s[i][2]));
a[i][1] = model->p4s[i][0];
a[i][2] = model->p4s[i][2];
a[i][3] = _one;
}
m13 = GetDet(a, 4);
for (i = 0; i < 4; i++) { /* find minor 14 */
a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
_mul(model->p4s[i][1], model->p4s[i][1])),
_mul(model->p4s[i][2], model->p4s[i][2]));
a[i][1] = model->p4s[i][0];
a[i][2] = model->p4s[i][1];
a[i][3] = _one;
}
m14 = GetDet(a, 4);
for (i = 0; i < 4; i++) { /* find minor 15 */
a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
_mul(model->p4s[i][1], model->p4s[i][1])),
_mul(model->p4s[i][2], model->p4s[i][2]));
a[i][1] = model->p4s[i][0];
a[i][2] = model->p4s[i][1];
a[i][3] = model->p4s[i][2];
}
m15 = GetDet(a, 4);
if (_eq(m11, 0)) {
rad = 0;
} else { /* center of sphere */
ho[0] = _div(_div(m12, m11), two);
ho[1] = _neg(_div(_div(m13, m11), two));
ho[2] = _div(_div(m14, m11), two);
norm = _sub(_add(_add(_mul(ho[0], ho[0]),
_mul(ho[1], ho[1])),
_mul(ho[2], ho[2])),
_div(m15, m11));
if (_ge(norm, 0)) {
rad = _sqrt(norm);
}
}
if (_le(rad, 0)) {
goto EXIT;
}
// Check distance
for (i = 0; i < 4; i++) {
for (j = (i + 1); j < 4; j++) {
tmpf = GetDistance(model->p4s[i], model->p4s[j]);
if (_lt(tmpf, rad) || _lt(tmpf, model->rad_min)) {
goto EXIT;
}
}
}
// Update offset
for (i = 1; i < IST_SPHERE_OFFSET_NUM; i++) {
for (j = 0; j < 3; ++j) {
model->offsets[IST_SPHERE_OFFSET_NUM - i][j] = model->offsets[IST_SPHERE_OFFSET_NUM - i - 1][j];
}
}
for (j = 0; j < 3; ++j) {
model->offsets[0][j] = ho[j];
}
for (i = (IST_SPHERE_DATAMAX >> 1); i < IST_SPHERE_DATAMAX; i++) {
for (j = 0; j < 3; ++j) {
model->data[i][j] = _max;
}
}
// Check offset buffer full
if (IsInitedVector(model->offsets[IST_SPHERE_OFFSET_NUM - 1])) {
goto EXIT;
}
// Calculate mean bias and radius
if (!GetParams(model, rad)) {
goto EXIT;
}
return ISTTRUE;
EXIT:
return ISTFALSE;
}
