void ReceiverProfile<T,I>::onEnable()
{
LOG4CPLUS_TRACE_METHOD( (logger<T,I>()), __PRETTY_FUNCTION__ );
//assert(callbacks);
if( callbacks )
{
LOG4CPLUS_TRACE((logger<T,I>()), "Trying access callbacks pointer "
+ cast_to_string(callbacks) );
const std::string ch_id = callbacks->get_channel_id();
LOG4CPLUS_TRACE((logger<T,I>()), "Trying allocate channel \"" + ch_id + "\"");
mChannelID = iviLink::Channel::allocateChannel(ch_id, this, eRealTime);
if (mChannelID)
{
LOG4CPLUS_TRACE((logger<T,I>()), "Channel \""
+ ch_id
+ "\" allocated, starting the communication...");
}
else
{
LOG4CPLUS_ERROR((logger<T,I>()), "allocate Channel \""
+ ch_id
+ "\" failed");
killProcess(1);
}
}
else
LOG4CPLUS_ERROR((logger<T,I>()), "Can't find application callbacks, so can't get correct channel id");
}
void server::
open_listening_socket (
)
{
if (!sock)
{
int status = create_listener(sock,listening_port,listening_ip);
const int port_used = listening_port;
// if there was an error then clear this object
if (status < 0)
{
max_connections_mutex.lock();
listening_port_mutex.lock();
listening_ip_mutex.lock();
listening_ip = "";
listening_port = 0;
max_connections = 1000;
graceful_close_timeout = 500;
listening_port_mutex.unlock();
listening_ip_mutex.unlock();
max_connections_mutex.unlock();
}
// throw an exception for the error
if (status == PORTINUSE)
{
throw dlib::socket_error(
EPORT_IN_USE,
"error occurred in server::start()\nport " + cast_to_string(port_used) + " already in use"
);
}
else if (status == OTHER_ERROR)
{
throw dlib::socket_error(
"error occurred in server::start()\nunable to create listener"
);
}
}
running_mutex.lock();
running = true;
running_mutex.unlock();
}
virtual void start_element (
const unsigned long line_number,
const std::string& name,
const dlib::attribute_list& atts
)
{
try
{
if (ts.size() == 0)
{
if (name != "dataset")
{
std::ostringstream sout;
sout << "Invalid XML document. Root tag must be <dataset>. Found <" << name << "> instead.";
throw dlib::error(sout.str());
}
else
{
ts.push_back(name);
return;
}
}
if (name == "box")
{
if (atts.is_in_list("top")) temp_box.rect.top() = sa = atts["top"];
else throw dlib::error("<box> missing required attribute 'top'");
if (atts.is_in_list("left")) temp_box.rect.left() = sa = atts["left"];
else throw dlib::error("<box> missing required attribute 'left'");
if (atts.is_in_list("width")) temp_box.rect.right() = sa = atts["width"];
else throw dlib::error("<box> missing required attribute 'width'");
if (atts.is_in_list("height")) temp_box.rect.bottom() = sa = atts["height"];
else throw dlib::error("<box> missing required attribute 'height'");
if (atts.is_in_list("difficult")) temp_box.difficult = sa = atts["difficult"];
if (atts.is_in_list("truncated")) temp_box.truncated = sa = atts["truncated"];
if (atts.is_in_list("occluded")) temp_box.occluded = sa = atts["occluded"];
temp_box.rect.bottom() += temp_box.rect.top()-1;
temp_box.rect.right() += temp_box.rect.left()-1;
}
else if (name == "part" && ts.back() == "box")
{
point temp;
if (atts.is_in_list("x")) temp.x() = sa = atts["x"];
else throw dlib::error("<part> missing required attribute 'x'");
if (atts.is_in_list("y")) temp.y() = sa = atts["y"];
else throw dlib::error("<part> missing required attribute 'y'");
if (atts.is_in_list("name"))
{
if (temp_box.parts.count(atts["name"])==0)
{
temp_box.parts[atts["name"]] = temp;
}
else
{
throw dlib::error("<part> with name '" + atts["name"] + "' is defined more than one time in a single box.");
}
}
else
{
throw dlib::error("<part> missing required attribute 'name'");
}
}
else if (name == "image")
{
temp_image.boxes.clear();
if (atts.is_in_list("file")) temp_image.filename = atts["file"];
else throw dlib::error("<image> missing required attribute 'file'");
}
ts.push_back(name);
}
catch (error& e)
{
throw dlib::error("Error on line " + cast_to_string(line_number) + ": " + e.what());
}
}
std::vector<labeled_sentence> parse_conll_data (
const std::string& filename
)
{
std::vector<labeled_sentence> result;
labeled_sentence sentence;
ifstream fin(filename.c_str());
std::string line;
unsigned long line_number = 0;
while(getline(fin, line))
{
++line_number;
const std::vector<std::string>& toks = split(line," \t\n");
if (toks.size() == 4)
{
sentence.push_back(make_pair(toks[0], lookup_conll_label(toks[3])));
}
else if (toks.size() == 0)
{
// this is the end of the sentence
result.push_back(sentence);
sentence.clear();
}
else
{
throw dlib::error("CONNLL PARSE ERROR, wrong number of tokens in line " + cast_to_string(line_number));
}
}
return result;
}
void png_loader::read_image( const char* filename )
{
ld_.reset(new LibpngData);
if ( filename == NULL )
{
throw image_load_error("png_loader: invalid filename, it is NULL");
}
FILE *fp = fopen( filename, "rb" );
if ( !fp )
{
throw image_load_error(std::string("png_loader: unable to open file ") + filename);
}
png_byte sig[8];
if (fread( sig, 1, 8, fp ) != 8)
{
fclose( fp );
throw image_load_error(std::string("png_loader: error reading file ") + filename);
}
if ( png_sig_cmp( sig, 0, 8 ) != 0 )
{
fclose( fp );
throw image_load_error(std::string("png_loader: format error in file ") + filename);
}
ld_->png_ptr_ = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, &png_loader_user_error_fn_silent, &png_loader_user_warning_fn_silent );
if ( ld_->png_ptr_ == NULL )
{
fclose( fp );
throw image_load_error(std::string("png_loader: parse error in file ") + filename);
}
ld_->info_ptr_ = png_create_info_struct( ld_->png_ptr_ );
if ( ld_->info_ptr_ == NULL )
{
fclose( fp );
png_destroy_read_struct( &( ld_->png_ptr_ ), ( png_infopp )NULL, ( png_infopp )NULL );
throw image_load_error(std::string("png_loader: parse error in file ") + filename);
}
ld_->end_info_ = png_create_info_struct( ld_->png_ptr_ );
if ( ld_->end_info_ == NULL )
{
fclose( fp );
png_destroy_read_struct( &( ld_->png_ptr_ ), &( ld_->info_ptr_ ), ( png_infopp )NULL );
throw image_load_error(std::string("png_loader: parse error in file ") + filename);
}
if (setjmp(png_jmpbuf(ld_->png_ptr_)))
{
// If we get here, we had a problem writing the file
fclose(fp);
png_destroy_read_struct( &( ld_->png_ptr_ ), &( ld_->info_ptr_ ), &( ld_->end_info_ ) );
throw image_load_error(std::string("png_loader: parse error in file ") + filename);
}
png_set_palette_to_rgb(ld_->png_ptr_);
png_init_io( ld_->png_ptr_, fp );
png_set_sig_bytes( ld_->png_ptr_, 8 );
// flags force one byte per channel output
byte_orderer bo;
int png_transforms = PNG_TRANSFORM_PACKING;
if (bo.host_is_little_endian())
png_transforms |= PNG_TRANSFORM_SWAP_ENDIAN;
png_read_png( ld_->png_ptr_, ld_->info_ptr_, png_transforms, NULL );
height_ = png_get_image_height( ld_->png_ptr_, ld_->info_ptr_ );
width_ = png_get_image_width( ld_->png_ptr_, ld_->info_ptr_ );
bit_depth_ = png_get_bit_depth( ld_->png_ptr_, ld_->info_ptr_ );
color_type_ = png_get_color_type( ld_->png_ptr_, ld_-> info_ptr_ );
if (color_type_ != PNG_COLOR_TYPE_GRAY &&
color_type_ != PNG_COLOR_TYPE_RGB &&
color_type_ != PNG_COLOR_TYPE_RGB_ALPHA )
{
fclose( fp );
png_destroy_read_struct( &( ld_->png_ptr_ ), &( ld_->info_ptr_ ), &( ld_->end_info_ ) );
throw image_load_error(std::string("png_loader: unsupported color type in file ") + filename);
}
if (bit_depth_ != 8 && bit_depth_ != 16)
{
fclose( fp );
png_destroy_read_struct( &( ld_->png_ptr_ ), &( ld_->info_ptr_ ), &( ld_->end_info_ ) );
throw image_load_error("png_loader: unsupported bit depth of " + cast_to_string(bit_depth_) + " in file " + std::string(filename));
}
ld_->row_pointers_ = png_get_rows( ld_->png_ptr_, ld_->info_ptr_ );
fclose( fp );
if ( ld_->row_pointers_ == NULL )
{
png_destroy_read_struct( &( ld_->png_ptr_ ), &( ld_->info_ptr_ ), &( ld_->end_info_ ) );
throw image_load_error(std::string("png_loader: parse error in file ") + filename);
}
}
