struct expr *prefix(char *expect)
{
struct expr *res = NULL;
int toktype = tok->type;
switch (toktype)
{
case IDENTIFIER:
return identexpr(strdup(tok->val));
case LPAREN:
res = expression(0);
eat(RPAREN);
return res;
case PLUS: case MINUS: case NOT:
return unopexpr(toktype, expression(lbp(toktype) - 1));
case REAL:
return expr_from_val(realval(atof(tok->val)));
case INT:
return expr_from_val(intval(atoi(tok->val)));
case CHAR:
return expr_from_val(charval(tok->val[1]));
case STRING:
return expr_from_val(strval(strdup(tok->val)));
case TRUE:
return expr_from_val(boolval(1));
case FALSE:
return expr_from_val(boolval(0));
case NULLKW:
return nullexpr();
default:
syntaxerror("expected %s, not %s", expect, tok->val);
return NULL;
}
}
cv::Mat getLBPHist()
{
// Calc LBP
cv::Mat lbp_image = lbp(face);
// Spatial histogram
return spatialHistogram(lbp_image,
static_cast<int>(std::pow(2.0, static_cast<double>(LBP_NEIGHBORS))),
LBP_GRID_X, LBP_GRID_Y);
}
struct expr *infix(struct expr *left, char *expect)
{
exprlist_t args;
int toktype = tok->type;
char *ident;
switch (toktype)
{
case PLUS: case MINUS: case STAR: case SLASH: case OR: case XOR:
case LT: case LE: case GT: case GE: case NEQ: case EQ: case AND:
return binopexpr(left, toktype, expression(lbp(toktype)));
case LPAREN:
if (left->exprtype != identtype)
syntaxerror("calling non-callable expression");
args = empty_exprlist();
if (lookahead[0]->type != COMMA && lookahead[0]->type != RPAREN)
list_push_back(args, expression(0));
while (lookahead[0]->type == COMMA)
{
eat(COMMA);
list_push_back(args, expression(0));
}
eat(RPAREN);
ident = strdup(left->val.ident);
left->type = NULL; // To prevent segfaults when freeing the expr
free_expression(left);
return funcallexpr(ident, args);
case LSQBRACKET:
args = empty_exprlist();
list_push_back(args, expression(0));
while (lookahead[0]->type == COMMA)
{
eat(COMMA);
list_push_back(args, expression(0));
}
eat(RSQBRACKET);
return arrayexpr(left, args);
case DOT:
eat(IDENTIFIER);
char *ident = strdup(tok->val);
return record_access(left, ident);
case DEREF:
return make_deref(left);
default:
syntaxerror("expected %s, not %s", expect, tok->val);
next();
switch (tok->type)
{
case ENDOFFILE: return expr_from_val(0);
default: return infix(left, "expression");
}
}
}
struct expr *expression(int rbp)
{
next();
struct expr *left = prefix("expression");
struct pos pos;
left->pos = *tok->pos;
while (rbp < lbp(lookahead[0]->type))
{
next();
pos = left->pos;
left = infix(left, "expression");
left->pos.line = pos.line;
left->pos.charstart = pos.charstart;
left->pos.len = tok->pos->charstart + tok->pos->len - pos.charstart;
}
return left;
}
cv::Mat LBP(cv::Mat input){
cv::Mat lbp((input.rows - 2), (input.cols - 2), CV_8U);
int center;
int BIT[8];
for (int m = 0; m<(input.rows - 2); m++){
for (int n = 0; n<(input.cols - 2); n++){
center = (input.at<uchar>(m + 1, n + 1));
if (input.at<uchar>(m, n)>center)
BIT[0] = 1;
else
BIT[0] = 0;
if (input.at<uchar>(m, n + 1) >= center)
BIT[1] = 1;
else
BIT[1] = 0;
if (input.at<uchar>(m, n + 2) >= center)
BIT[2] = 1;
else
BIT[2] = 0;
if (input.at<uchar>(m + 1, n + 2) >= center)
BIT[3] = 1;
else
BIT[3] = 0;
if (input.at<uchar>(m + 2, n + 2) >= center)
BIT[4] = 1;
else
BIT[4] = 0;
if (input.at<uchar>(m + 2, n + 1) >= center)
BIT[5] = 1;
else
BIT[5] = 0;
if (input.at<uchar>(m + 2, n) >= center)
BIT[6] = 1;
else
BIT[6] = 0;
if (input.at<uchar>(m + 1, n) >= center)
BIT[7] = 1;
else
BIT[7] = 0;
lbp.at<uchar>(m, n) = (int)(BIT[7] + 2 * BIT[6] + 4 * BIT[5] + 8 * BIT[4] + 16 * BIT[3] + 32 * BIT[2] + 64 * BIT[1] + 128 * BIT[0]);
}
}
return lbp;
}
cv::Mat getLBP()
{
return lbp(face);
}
