void init_ogr(const std::string& outfile) {
OGRRegisterAll();
const char* driver_name = "SQLite";
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name);
if (driver == NULL) {
std::cerr << driver_name << " driver not available.\n";
exit(1);
}
CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
const char* options[] = { "SPATIALITE=TRUE", NULL };
m_data_source = driver->CreateDataSource(outfile.c_str(), const_cast<char**>(options));
if (m_data_source == NULL) {
std::cerr << "Creation of output file failed.\n";
exit(1);
}
m_layer_point = init_layer("planet_osm_point", m_fields_nodes, wkbPoint);
m_layer_line = init_layer("planet_osm_line", m_fields_ways, wkbLineString);
m_layer_polygon = init_layer("planet_osm_polygon", m_fields_areas, wkbMultiPolygon);
stringv fields_roads;
fields_roads.push_back("railway");
fields_roads.push_back("highway");
fields_roads.push_back("boundary");
m_layer_roads = init_layer("planet_osm_roads", fields_roads, wkbLineString);
}
static DFBResult
sh_du_add_region( CoreLayer *layer,
void *driver_data,
void *layer_data,
void *region_data,
CoreLayerRegionConfig *config )
{
SHGfxDriverData *drv;
SHDuLayerData *lyr;
DFBResult ret;
D_DEBUG_AT( SH_DU_LAYER, "%s( %u )\n",
__FUNCTION__, dfb_layer_id( layer ) );
D_UNUSED_P( region_data );
drv = (SHGfxDriverData *)driver_data;
lyr = (SHDuLayerData *)layer_data;
init_layer( drv, lyr, dfb_layer_id( layer ), config );
ret = update_layer( drv, lyr, PLANE_ALL, NULL );
if (ret == DFB_OK)
ret = sh_du_add_layer( dfb_layer_screen( layer ), driver_data,
lyr->id, lyr->plane.id, &lyr->level );
return ret;
}
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;
}
int main(int argc, char *argv[])
{
unsigned int args[4];
int status = 0;
int retry = 0;
int flags = 0;
int ret;
pthread_t tid;
__disp_output_type_t disp_output_type;
int mic_activated;
INIT_CMD_PIPE();
init_script(atoi(argv[2]));
disp = open("/dev/disp", O_RDWR);
if (disp == -1) {
db_error("hdmitester: open /dev/disp failed(%s)\n", strerror(errno));
goto err;
}
args[0] = 0;
disp_output_type = (__disp_output_type_t)ioctl(disp, DISP_CMD_GET_OUTPUT_TYPE,(void*)args);
if(script_fetch("mic", "activated", &mic_activated,1)){
mic_activated=0;
}
/* test main loop */
while (1) {
if(disp_output_type==DISP_OUTPUT_TYPE_LCD)
args[0] = 1;
else
args[0] = 0;
ret = ioctl(disp, DISP_CMD_HDMI_GET_HPD_STATUS, args);
if (ret == 1) {
flags = 0;
if (status == 1) {
sleep(1);
continue;
}
/* try three times before go on...
* it will take 3 second.
*/
if (retry < 3) {
retry++;
sleep(1);
continue;
}
if(disp_output_type==DISP_OUTPUT_TYPE_LCD){
/* detect and set output mode */
ret = detect_output_mode();
if (ret < 0) {
goto err;
}
args[0] = 1;
args[1] = output_mode;
ret = ioctl(disp, DISP_CMD_HDMI_SET_MODE, args);
if (ret < 0) {
db_error("hdmitester: set hdmi output mode failed(%d)\n", ret);
goto err;
}
/* init layer */
ret = init_layer();
if (ret < 0) {
db_error("hdmitester: init layer failed\n");
goto err;
}
/* set hdmi on */
args[0] = 1;
ret = ioctl(disp, DISP_CMD_HDMI_ON, args);
if (ret < 0) {
db_error("hdmitester: set hdmi on failed(%d)\n", ret);
exit_layer();
goto err;
}
/* create sound play thread */
sound_play_stop = 0;
//ret = pthread_create(&tid, NULL, sound_play, NULL);
ret=0;
if (ret != 0) {
db_error("hdmitester: create sound play thread failed\n");
exit_layer();
args[0] = 1;
ioctl(disp, DISP_CMD_HDMI_OFF, args);
goto err;
}
}else
if((disp_output_type==DISP_OUTPUT_TYPE_HDMI)&&(!mic_activated)){
/* create sound play thread */
sound_play_stop = 0;
ret = pthread_create(&tid, NULL, sound_play, NULL);
if (ret != 0) {
db_error("hdmitester: create sound play thread failed\n");
exit_layer();
args[0] = 1;
ioctl(disp, DISP_CMD_HDMI_OFF, args);
goto err;
}
}
status = 1;
SEND_CMD_PIPE_OK();
}
else {
void *retval;
/* reset retry to 0 */
retry = 0;
if (status == 0) {
sleep(1);
continue;
}
if (flags < 3) {
flags++;
sleep(1);
continue;
}
status = 0;
if(disp_output_type==DISP_OUTPUT_TYPE_LCD){
/* end sound play thread */
sound_play_stop = 1;
db_msg("hdmitester: waiting for sound play thread finish...\n");
if (pthread_join(tid, &retval)) {
db_error("hdmitester: can't join with sound play thread\n");
}
db_msg("hdmitester: sound play thread exit code #%d\n", (int)retval);
exit_layer();
args[0] = 1;
ioctl(disp, DISP_CMD_HDMI_OFF, args);
}
else
if((disp_output_type==DISP_OUTPUT_TYPE_HDMI)&&(!mic_activated)){
/* end sound play thread */
sound_play_stop = 1;
db_msg("hdmitester: waiting for sound play thread finish...\n");
if (pthread_join(tid, &retval)) {
db_error("hdmitester: can't join with sound play thread\n");
}
db_msg("hdmitester: sound play thread exit code #%d\n", (int)retval);
}
}
/* sleep 1 second */
sleep(1);
}
err:
SEND_CMD_PIPE_FAIL();
close(disp);
deinit_script();
return -1;
}
OutputLayer(unsigned int N,Ply *p) {
init_layer(N,p);
}
InputLayer(unsigned int N,Ply *p) {
init_layer(N);
}
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;
}
