int mdt_feature_aligned_residue_pair_add(
struct mdt_library *mlib, const char *name, mod_mdt_calc precalc_type,
int protein1, int protein2, gboolean asymmetric,
mdt_cb_feature_aligned_residue_pair getbin, void *data,
mdt_cb_free freefunc, GError **err)
{
char *fullname;
struct mdt_feature_aligned_residue_pair *feat;
int nfeat;
if (!check_protein_pair(protein1, protein2, "Aligned residue pair", err)) {
return -1;
}
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_ALIGNED_RESIDUE_PAIR,
data, freefunc)->u.aligned_residue_pair);
feat->protein1 = protein1;
feat->protein2 = protein2;
feat->getbin = getbin;
fullname = g_strdup_printf("%s of proteins (%d,%d)", name, protein1,
protein2);
mod_mdt_libfeature_register(&mlib->base, nfeat, fullname, precalc_type,
protein2 == 1 ? MOD_MDTP_AB : MOD_MDTP_AC,
MOD_MDTS_RESIDUE_PAIR, asymmetric, 0);
g_free(fullname);
return nfeat;
}
int mdt_feature_protein_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, int protein,
mdt_cb_feature_protein getbin, void *data,
mdt_cb_free freefunc, GError **err)
{
GString *fullname;
struct mdt_feature_protein *feat;
mod_mdt_protein mdt_protein;
int nfeat;
if (!check_protein(protein, "Protein", &mdt_protein, err)) {
return -1;
}
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_PROTEIN, data,
freefunc)->u.protein);
feat->protein = protein;
feat->getbin = getbin;
fullname = g_string_new(name);
g_string_append_printf(fullname, " of protein %d", protein);
mod_mdt_libfeature_register(&mlib->base, nfeat, fullname->str, precalc_type,
mdt_protein, MOD_MDTS_PROTEIN, FALSE, 0);
g_string_free(fullname, TRUE);
return nfeat;
}
int mdt_feature_protein_pair_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, int protein1,
int protein2,
mdt_cb_feature_protein_pair getbin, void *data,
mdt_cb_free freefunc, GError **err)
{
char *fullname;
struct mdt_feature_protein_pair *feat;
int nfeat;
if (!check_protein_pair(protein1, protein2, "Protein pair", err)) {
return -1;
}
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_PROTEIN_PAIR,
data, freefunc)->u.protein_pair);
feat->protein1 = protein1;
feat->protein2 = protein2;
feat->getbin = getbin;
fullname = g_strdup_printf("%s of proteins (%d,%d)", name, protein1,
protein2);
mod_mdt_libfeature_register(&mlib->base, nfeat, fullname, precalc_type,
protein2 == 1 ? MOD_MDTP_AB : MOD_MDTP_AC,
MOD_MDTS_PROTEIN, FALSE, 0);
g_free(fullname);
return nfeat;
}
void node(const osmium::Node& node) {
if (m_cfg.add_untagged_nodes || !node.tags().empty()) {
gdalcpp::Feature feature{m_layer_point, m_factory.create_point(node)};
feature.set_field("id", double(node.id()));
add_feature(feature, node);
}
}
void way(const osmium::Way& way) {
try {
gdalcpp::Feature feature{m_layer_linestring, m_factory.create_linestring(way)};
feature.set_field("id", int32_t(way.id()));
add_feature(feature, way);
} catch (const osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for way " << way.id() << ".\n";
}
}
void t_hdr_supported::add_features(const list<string> &l) {
if (l.empty()) return;
for (list<string>::const_iterator i = l.begin(); i != l.end(); i++)
{
add_feature(*i);
}
populated = true;
}
void area(const osmium::Area& area) {
try {
gdalcpp::Feature feature{m_layer_multipolygon, m_factory.create_multipolygon(area)};
feature.set_field("id", int32_t(area.id()));
add_feature(feature, area);
} catch (const osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for area "
<< area.id()
<< " created from "
<< (area.from_way() ? "way" : "relation")
<< " with id="
<< area.orig_id() << ".\n";
}
}
int mdt_feature_angle_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type,
mdt_cb_feature_bond getbin, void *data,
mdt_cb_free freefunc)
{
struct mdt_feature_bond *feat;
int nfeat;
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_BOND, data, freefunc)->u.bond);
feat->type = MDT_BOND_TYPE_ANGLE;
feat->getbin = getbin;
mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type,
MOD_MDTP_A, MOD_MDTS_ANGLE, FALSE, 0);
return nfeat;
}
int mdt_feature_tuple_pair_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type,
mdt_cb_feature_tuple_pair getbin, void *data,
mdt_cb_free freefunc)
{
struct mdt_feature_tuple_pair *feat;
int nfeat;
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_TUPLE_PAIR,
data, freefunc)->u.tuple_pair);
feat->getbin = getbin;
mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type,
MOD_MDTP_A, MOD_MDTS_TUPLE_PAIR, TRUE, 0);
return nfeat;
}
int mdt_feature_atom_pair_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, gboolean asymmetric,
mdt_cb_feature_atom_pair getbin, void *data,
mdt_cb_free freefunc)
{
struct mdt_feature_atom_pair *feat;
int nfeat;
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_ATOM_PAIR, data,
freefunc)->u.atom_pair);
feat->getbin = getbin;
mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type,
MOD_MDTP_A, MOD_MDTS_ATOM_PAIR, asymmetric, 0);
mdt_feature_add_needed_file(mlib, nfeat, MOD_MDTF_STRUCTURE);
return nfeat;
}
int mdt_feature_residue_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, int protein, int delta,
int align_delta, gboolean pos2,
int bin_seq_outrange, mdt_cb_feature_residue getbin,
void *data, mdt_cb_free freefunc, GError **err)
{
GString *fullname;
struct mdt_feature_residue *feat;
mod_mdt_protein mdt_protein;
int nfeat;
if (!check_protein(protein, "Residue", &mdt_protein, err)) {
return -1;
}
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_RESIDUE, data,
freefunc)->u.residue);
feat->protein = protein;
feat->delta = delta;
feat->align_delta = align_delta;
feat->pos2 = pos2;
feat->bin_seq_outrange = bin_seq_outrange;
feat->getbin = getbin;
fullname = g_string_new(name);
g_string_append_printf(fullname, " of protein %d", protein);
if (pos2) {
g_string_append(fullname, " at pos2");
}
if (delta != 0) {
g_string_append_printf(fullname, ", at delta %d", delta);
}
if (align_delta != 0) {
g_string_append_printf(fullname, ", at alignment delta %d", align_delta);
}
mod_mdt_libfeature_register(&mlib->base, nfeat, fullname->str, precalc_type,
mdt_protein,
pos2 ? MOD_MDTS_RESIDUE_PAIR : MOD_MDTS_RESIDUE,
FALSE, 0);
g_string_free(fullname, TRUE);
return nfeat;
}
int mdt_feature_group_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, int ifeat1, int ifeat2,
mdt_cb_feature_group getbin, void *data,
mdt_cb_free freefunc, GError **err)
{
struct mdt_feature_group *feat;
int nfeat;
if (!check_feature(ifeat1, mlib, 1, err)
|| !check_feature(ifeat2, mlib, 2, err)) {
return -1;
}
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_GROUP, data,
freefunc)->u.group);
feat->ifeat1 = ifeat1;
feat->ifeat2 = ifeat2;
feat->getbin = getbin;
mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type,
MOD_MDTP_A, MOD_MDTS_PROTEIN, FALSE, 0);
return nfeat;
}
static int
merge_hwe (struct hwentry * dst, struct hwentry * src)
{
merge_str(vendor);
merge_str(product);
merge_str(revision);
merge_str(uid_attribute);
merge_str(features);
merge_str(hwhandler);
merge_str(selector);
merge_str(checker_name);
merge_str(prio_name);
merge_str(prio_args);
merge_str(alias_prefix);
merge_str(bl_product);
merge_num(pgpolicy);
merge_num(pgfailback);
merge_num(rr_weight);
merge_num(no_path_retry);
merge_num(minio);
merge_num(minio_rq);
merge_num(pg_timeout);
merge_num(flush_on_last_del);
merge_num(fast_io_fail);
merge_num(dev_loss);
merge_num(user_friendly_names);
merge_num(retain_hwhandler);
merge_num(detect_prio);
/*
* Make sure features is consistent with
* no_path_retry
*/
if (dst->no_path_retry == NO_PATH_RETRY_FAIL)
remove_feature(&dst->features, "queue_if_no_path");
else if (dst->no_path_retry != NO_PATH_RETRY_UNDEF)
add_feature(&dst->features, "queue_if_no_path");
return 0;
}
layer_t *avg_pooling(layer_t *target, int factor) {
layer_t *result_layer = init_layer();
for (int stack = 0; stack < target->size; stack += 1) {
int result_size = (target->feature[stack]->size)/factor;
image_t *result = init_image2D(result_size);
for(int i = 0; i < result_size; i += 1) {
for(int j = 0; j < result_size; j += 1) {
float sum = 0;
for(int m = 0; m < factor; m += 1) {
for(int n = 0; n < factor; n += 1) {
sum += target->feature[stack]->element[0][i*target->feature[stack]->size*factor+j*factor+m*target->feature[stack]->size+n];
}
}
result->element[0][i*result->size+j] = sum / (target->feature[stack]->size * target->feature[stack]->size);
}
}
add_feature(result_layer, result);
}
return result_layer;
}
void FeatureMap :: read_from_file( string filename ){
ifstream input_file( filename.c_str() );
size_t num_features;
input_file >> num_features;
for ( size_t i = 0; i < num_features; i++ ){
pair<float, float> ctr;
input_file >> ctr.first >> ctr.second;
string shape_name;
input_file >> shape_name;
pair<int, int> size;
input_file >> size.first >> size.second;
size_t feature_size;
input_file >> feature_size;
vector<float> feature(feature_size);
for( size_t j = 0; j < feature_size; j++ ){
input_file >> feature[j];
}
int label;
input_file >> label;
add_feature( ctr, name_to_shape(shape_name), size, feature, label );
}
}
int mdt_feature_residue_pair_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, int protein,
gboolean asymmetric,
mdt_cb_feature_residue_pair getbin, void *data,
mdt_cb_free freefunc, GError **err)
{
struct mdt_feature_residue_pair *feat;
mod_mdt_protein mdt_protein;
int nfeat;
if (!check_protein(protein, "Residue pair", &mdt_protein, err)) {
return -1;
}
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_RESIDUE_PAIR,
data, freefunc)->u.residue_pair);
feat->protein = protein;
feat->getbin = getbin;
mod_mdt_libfeature_register(&mlib->base, nfeat, name, precalc_type,
mdt_protein, MOD_MDTS_RESIDUE_PAIR, asymmetric,
0);
return nfeat;
}
int mdt_feature_tuple_add(struct mdt_library *mlib, const char *name,
mod_mdt_calc precalc_type, gboolean pos2,
mdt_cb_feature_tuple getbin, void *data,
mdt_cb_free freefunc)
{
GString *fullname;
struct mdt_feature_tuple *feat;
int nfeat;
feat = &(add_feature(mlib, &nfeat, MDT_FEATURE_TUPLE, data,
freefunc)->u.tuple);
feat->pos2 = pos2;
feat->getbin = getbin;
fullname = g_string_new(name);
if (pos2) {
g_string_append(fullname, " at pos2");
}
mod_mdt_libfeature_register(&mlib->base, nfeat, fullname->str, precalc_type,
MOD_MDTP_A,
pos2 ? MOD_MDTS_TUPLE_PAIR : MOD_MDTS_TUPLE,
FALSE, 0);
g_string_free(fullname, TRUE);
return nfeat;
}
static void setup_tun_net(char *arg)
{
struct device *dev;
struct net_info *net_info = malloc(sizeof(*net_info));
int ipfd;
u32 ip = INADDR_ANY;
bool bridging = false;
char tapif[IFNAMSIZ], *p;
struct virtio_net_config conf;
net_info->tunfd = get_tun_device(tapif);
dev = new_device("net", VIRTIO_ID_NET);
dev->priv = net_info;
add_virtqueue(dev, VIRTQUEUE_NUM, net_input);
add_virtqueue(dev, VIRTQUEUE_NUM, net_output);
ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (ipfd < 0)
err(1, "opening IP socket");
if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) {
arg += strlen(BRIDGE_PFX);
bridging = true;
}
p = strchr(arg, ':');
if (p) {
str2mac(p+1, conf.mac);
add_feature(dev, VIRTIO_NET_F_MAC);
*p = '\0';
}
if (bridging)
add_to_bridge(ipfd, tapif, arg);
else
ip = str2ip(arg);
configure_device(ipfd, tapif, ip);
add_feature(dev, VIRTIO_NET_F_CSUM);
add_feature(dev, VIRTIO_NET_F_GUEST_CSUM);
add_feature(dev, VIRTIO_NET_F_GUEST_TSO4);
add_feature(dev, VIRTIO_NET_F_GUEST_TSO6);
add_feature(dev, VIRTIO_NET_F_GUEST_ECN);
add_feature(dev, VIRTIO_NET_F_HOST_TSO4);
add_feature(dev, VIRTIO_NET_F_HOST_TSO6);
add_feature(dev, VIRTIO_NET_F_HOST_ECN);
add_feature(dev, VIRTIO_RING_F_INDIRECT_DESC);
set_config(dev, sizeof(conf), &conf);
close(ipfd);
devices.device_num++;
if (bridging)
verbose("device %u: tun %s attached to bridge: %s\n",
devices.device_num, tapif, arg);
else
verbose("device %u: tun %s: %s\n",
devices.device_num, tapif, arg);
}
/**
Fill the features DArray for [from][to cell
*/
void fill_features(Hashmap *featuremap, DArray *farr, int from, int to, FeaturedSentence sentence) {
char buffer[255];
if (from != to && to != 0) {
Word pword_w = (Word) DArray_get(sentence->words, from);
Word cword_w = (Word) DArray_get(sentence->words, to);
join(buffer, 2, pword_w->form, pword_w->postag);
add_feature(pword_ppos, buffer, featuremap, farr);
add_feature(pword, pword_w->form, featuremap, farr);
add_feature(ppos, pword_w->postag, featuremap, farr);
join(buffer, 2, cword_w->form, cword_w->postag);
add_feature(cword_cpos, buffer, featuremap, farr);
add_feature(cword, cword_w->form, featuremap, farr);
add_feature(cpos, cword_w->postag, featuremap, farr);
join(buffer, 4, pword_w->form, pword_w->postag, cword_w->form, cword_w->postag);
add_feature(pword_ppos_cword_cpos, buffer, featuremap, farr);
join(buffer, 3, pword_w->postag, cword_w->form, cword_w->postag);
add_feature(ppos_cword_cpos, buffer, featuremap, farr);
join(buffer, 3, pword_w->form, pword_w->postag, cword_w->postag);
add_feature(pword_ppos_cpos, buffer, featuremap, farr);
join(buffer, 3, pword_w->form, pword_w->postag, cword_w->form);
add_feature(pword_ppos_cword, buffer, featuremap, farr);
join(buffer, 2, pword_w->form, cword_w->form);
add_feature(pword_cword, buffer, featuremap, farr);
join(buffer, 2, pword_w->postag, cword_w->postag);
add_feature(ppos_cpos, buffer, featuremap, farr);
/*
char* pposP1_v;
char* pposM1_v;
char* cposM1_v;
char* cposP1_v;
if (from == DArray_count(sentence->words) - 1 )
pposP1_v = STOP;
else
pposP1_v = (char*)DArray_get(sentence->postags, from+1);
if (from == 0 )
pposM1_v = START;
else
pposM1_v = (char*)DArray_get(sentence->postags, from-1);
if (to == 0 )
cposM1_v = START;
else
cposM1_v = (char*)DArray_get(sentence->postags, to-1);
if (to == sentence->length - 1 )
cposP1_v = STOP;
else
cposP1_v = (char*)DArray_get(sentence->postags, to+1);
join(buffer, 4, ppos_v, pposP1_v, cposM1_v,cpos_v);
add_feature(ppos_pposP1_cposM1_cpos, buffer, featuremap,farr);
join(buffer, 4, pposM1_v, ppos_v, cposM1_v,cpos_v);
add_feature(pposM1_ppos_cposM1_cpos, buffer, featuremap,farr);
join(buffer, 4, ppos_v, pposP1_v, cpos_v,cposP1_v);
add_feature(ppos_pposP1_cpos_cposP1, buffer, featuremap,farr);
join(buffer, 4, pposM1_v, ppos_v, cpos_v,cposP1_v);
add_feature(pposM1_ppos_cpos_cposP1, buffer, featuremap,farr);
int left_context, right_context;
if (from < to){
left_context = from;
right_context = to;
}else{
left_context = to;
right_context = from;
}
for(int j = left_context + 1; j < right_context;j++){
join(buffer, 3, DArray_get(sentence->postags, left_context), DArray_get(sentence->postags, j), DArray_get(sentence->postags, right_context));
add_feature(ppos_bpos_cpos, buffer, featuremap, farr);
}
* */
}
}
void scan_image(SDL_Surface* image) {
predict_cascade_t* cascade = load_adaboost("adaboost_test2.txt");
features_array_t* features = alloc_features_array();
Uint32 red_pixel = SDL_MapRGB(image->format, 0, 255, 0);
for (int i = 0; i < 162336; ++i) {
feature_t f;
f.i = f.j = f.w = f.h = f.charac = f.value = -1;
add_feature(f, features);
}
const int padding = 2;
for (int scale = 24; scale < 100; scale *= 1.25) {
for (int i = 0; i < image->w - scale; i += padding) {
for (int j = 0; j < image->h - scale; j += padding) {
SDL_Surface* sub_window = extract_image(image, i, j, scale, scale);
convert_to_greyscale(sub_window);
//if (scale != 24) {
sub_window = scale_surface(sub_window, 24, 24);
//}
integral_image_t* integral_image = alloc_integral_image(sub_window->w, sub_window->h);
convert_to_integral_image(sub_window, integral_image);
SDL_FreeSurface(sub_window);
int k = 0;
cascade_t layer;
printf("\n=============================\n\n");
printf("x=%d y=%d\n", i, j);
while (k < cascade->nb_layers) {
compute_cascade_features(features, cascade->layers[k], integral_image);
layer.nb_features = cascade->layers[k]->T;
layer.alphas = cascade->layers[k]->alphas;
layer.thresholds = cascade->layers[k]->thresholds;
layer.parities = cascade->layers[k]->parities;
layer.features = cascade->layers[k]->features;
layer.strong_threshold = cascade->layers[k]->strong_threshold;
if (!strong_classify(features, &layer)) {
printf("non face layer=%d\n", k);
break;
}
++k;
}
free_integral_image(integral_image);
if (k == cascade->nb_layers) {
printf("---------------------------------------------------------detected\n");
for (int x = i; x < i + scale; ++x) {
putpixel(image, x, j, red_pixel);
}
for (int y = j; y < j + scale; ++y) {
putpixel(image, i, y, red_pixel);
}
for (int x = i; x < i + scale; ++x) {
putpixel(image, x, j + scale, red_pixel);
}
for (int y = j; y < j + scale; ++y) {
putpixel(image, i + scale, y, red_pixel);
}
}
}
}
}
SDL_SaveBMP(image, "../SDL/detection.bmp");
free_features_array(features);
free_predict_cascade(cascade);
}
/*L:195
* Our network is a Host<->Guest network. This can either use bridging or
* routing, but the principle is the same: it uses the "tun" device to inject
* packets into the Host as if they came in from a normal network card. We
* just shunt packets between the Guest and the tun device.
*/
static void setup_tun_net(char *arg)
{
struct device *dev;
struct net_info *net_info = malloc(sizeof(*net_info));
int ipfd;
u32 ip = INADDR_ANY;
bool bridging = false;
char tapif[IFNAMSIZ], *p;
struct virtio_net_config conf;
net_info->tunfd = get_tun_device(tapif);
/* First we create a new network device. */
dev = new_device("net", VIRTIO_ID_NET);
dev->priv = net_info;
/* Network devices need a recv and a send queue, just like console. */
add_virtqueue(dev, VIRTQUEUE_NUM, net_input);
add_virtqueue(dev, VIRTQUEUE_NUM, net_output);
/*
* We need a socket to perform the magic network ioctls to bring up the
* tap interface, connect to the bridge etc. Any socket will do!
*/
ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (ipfd < 0)
err(1, "opening IP socket");
/* If the command line was --tunnet=bridge:<name> do bridging. */
if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) {
arg += strlen(BRIDGE_PFX);
bridging = true;
}
/* A mac address may follow the bridge name or IP address */
p = strchr(arg, ':');
if (p) {
str2mac(p+1, conf.mac);
add_feature(dev, VIRTIO_NET_F_MAC);
*p = '\0';
}
/* arg is now either an IP address or a bridge name */
if (bridging)
add_to_bridge(ipfd, tapif, arg);
else
ip = str2ip(arg);
/* Set up the tun device. */
configure_device(ipfd, tapif, ip);
/* Expect Guest to handle everything except UFO */
add_feature(dev, VIRTIO_NET_F_CSUM);
add_feature(dev, VIRTIO_NET_F_GUEST_CSUM);
add_feature(dev, VIRTIO_NET_F_GUEST_TSO4);
add_feature(dev, VIRTIO_NET_F_GUEST_TSO6);
add_feature(dev, VIRTIO_NET_F_GUEST_ECN);
add_feature(dev, VIRTIO_NET_F_HOST_TSO4);
add_feature(dev, VIRTIO_NET_F_HOST_TSO6);
add_feature(dev, VIRTIO_NET_F_HOST_ECN);
/* We handle indirect ring entries */
add_feature(dev, VIRTIO_RING_F_INDIRECT_DESC);
set_config(dev, sizeof(conf), &conf);
/* We don't need the socket any more; setup is done. */
close(ipfd);
devices.device_num++;
if (bridging)
verbose("device %u: tun %s attached to bridge: %s\n",
devices.device_num, tapif, arg);
else
verbose("device %u: tun %s: %s\n",
devices.device_num, tapif, arg);
}
int main(int argc, char *argv[])
{
boolean print_parse = FALSE;
boolean print_expanded = FALSE;
char *arg;
char *source_name = NULL;
char *output_name = NULL;
FILE *file;
add_header_handler("module", set_module);
add_header_handler("library", set_library);
add_header_handler(NULL, end_of_headers);
init_sym_table();
init_feature();
init_info();
init_expand();
init_compile();
#ifdef MACOS
add_feature(symbol("macos"));
# ifndef SHLB
argc = ccommand( &argv );
# endif
#endif
while ((arg = *++argv) != NULL) {
if (arg[0] == '-') {
switch (arg[1]) {
case 'd':
if (arg[2] == '\0') {
print_parse = TRUE;
print_expanded = TRUE;
}
else {
char *ptr;
for (ptr = arg+2; *ptr != '\0'; ptr++) {
switch (*ptr) {
case 'p':
print_parse = TRUE;
break;
case 'e':
print_expanded = TRUE;
break;
default:
fprintf(stderr, "Invalid thing to print: ``%c''\n",
*ptr);
usage();
}
}
}
break;
case 'o':
if (output_name != NULL) {
fprintf(stderr, "-o can only be used once.\n");
usage();
}
else if (arg[2] != '\0')
output_name = arg+2;
else if (*++argv == NULL) {
fprintf(stderr, "-o must be followed by the output "
"file name.\n");
usage();
}
else
output_name = *argv;
break;
case 'l':
if (LibraryName != NULL) {
fprintf(stderr, "-l can only be used once.\n");
usage();
}
if (arg[2] != '\0')
LibraryName = symbol(arg+2);
else if (*++argv == NULL) {
fprintf(stderr, "-l must be followed by the library "
"name.\n");
usage();
}
else
LibraryName = symbol(*argv);
break;
case 'q':
GiveWarnings = FALSE;
break;
case 'D':
if (arg[2] != '\0')
add_feature(symbol(arg + 2));
else if (*++argv == NULL) {
fprintf(stderr,
"-D must be followed by the feature to define.\n");
usage();
}
else
add_feature(symbol(*argv));
break;
case 'U':
if (arg[2] != '\0')
remove_feature(symbol(arg + 2));
else if (*++argv == NULL) {
fprintf(stderr, "-U must be followed by the feature "
"to undefine.\n");
usage();
}
else
remove_feature(symbol(*argv));
break;
default:
fprintf(stderr, "Invalid flag: ``%s''\n", arg);
usage();
}
}
else if (source_name != NULL) {
fprintf(stderr, "Too many files\n");
usage();
}
else
source_name = arg;
}
if (source_name == NULL)
usage();
yyin = fopen(source_name, "rb");
if (yyin == NULL) {
/* Try the same filename but in the current directory */
/* Start ptr at the null termination, and work backwards to a
path separator. */
char *ptr = source_name + strlen(source_name);
for ( ; ptr != source_name; ptr--) {
if (*ptr == '/' || *ptr == '\\') {
/* We're pointing at the path separator, which is too far */
ptr++;
break;
}
}
/* If ptr is a different string than source_name, and it isn't
the empty string... */
if (ptr != source_name && *ptr != 0) {
yyin = fopen(ptr, "rb");
}
if (yyin == NULL) {
perror(source_name);
exit(1);
}
}
current_file = source_name;
yyparse();
if (print_parse) {
printf("================ Original Parse Tree ================\n");
print_body(Program, 0);
}
if (nerrors != 0)
exit(1);
/* Do the various source-to-source expansions. */
expand(Program);
if (print_expanded) {
printf("================ Expanded Parse Tree ================\n");
print_body(Program, 0);
}
if (nerrors != 0)
exit(1);
/* Run environment analysis */
environment_analysis(Program);
if (nerrors != 0)
exit(1);
if (output_name == NULL)
output_name = make_output_name(source_name, ".dbc");
if (strcmp(output_name, "-") == 0)
file = stdout;
else
file = fopen(output_name, "wb");
if (file == NULL) {
perror(output_name);
exit(1);
}
dump_setup_output(source_name, file);
/* Generate code. */
compile(Program);
dump_finalize_output();
fclose(file);
exit(0);
return 0;
}
int main() {
int i;
printf("==== Initial status ====\n");
image_t *test_cimage1 = init_image2D(5);
for(i = 0; i < test_cimage1->size*test_cimage1->size; i += 1) {
if (i%2)
test_cimage1->element[0][i] = i;
else
test_cimage1->element[0][i] = -i;
}
image_t *test_cimage2 = init_image2D(5);
for(i = 0; i < test_cimage2->size*test_cimage2->size; i += 1) {
if (i%2)
test_cimage2->element[0][i] = i;
else
test_cimage2->element[0][i] = -i;
}
kernel_t *test_kernel1 = init_kernel2D(3);
for(i = 0; i < test_kernel1->size*test_kernel1->size; i += 1) {
test_kernel1->element[0][i] = (i%3)+1;
}
kernel_t *test_kernel2 = init_kernel2D(3);
for(i = 0; i < test_kernel2->size*test_kernel2->size; i += 1) {
test_kernel2->element[0][i] = -1;
}
printf("Images:\n");
layer_t *input_layer = init_layer();
add_feature(input_layer, test_cimage1);
add_feature(input_layer, test_cimage2);
printlayer(input_layer);
printf("Kernels:\n");
layer_t *kernel_layer = init_layer();
add_feature(kernel_layer, test_kernel1);
add_feature(kernel_layer, test_kernel2);
printlayer(kernel_layer);
printf("\n");
printf("==== Test convolution ====\n");
printf("Convolution2D:\n");
layer_t *result_clayer = convolution2D(input_layer, kernel_layer);
printlayer(result_clayer);
printf("\n");
printf("==== Test activator function ====\n");
layer_t *result_alayer = activator(result_clayer, relu);
printlayer(result_alayer);
printf("\n");
printf("==== Test pooling ====\n");
printf("Max Pooling:\n");
layer_t *result_player = max_pooling(result_alayer, 3);
printlayer(result_player);
printf("Avg Pooling:\n");
result_player = avg_pooling(result_alayer, 3);
printlayer(result_player);
printf("Min Pooling:\n");
result_player = min_pooling(result_alayer, 3);
printlayer(result_player);
printf("=== Test image3D ===\n");
image_t *image3d = init_image3D(3, 3);
image3d->element[0][1] = 1;
image3d->element[1][1] = 2;
image3d->element[2][1] = 3;
printmap(image3d);
return 0;
}
