void Volume::export_off()
{
QFileDialog filedialog(mw, tr("Export surface to file"));
filedialog.setFileMode(QFileDialog::AnyFile);
filedialog.setNameFilter(tr("OFF files (*.off);;"
"All files (*)"));
filedialog.setAcceptMode(QFileDialog::AcceptSave);
filedialog.setDefaultSuffix("off");
if(filedialog.exec())
{
const QString filename = filedialog.selectedFiles().front();
std::cerr << "Saving to file \"" << filename.toLocal8Bit().data() << "\"...";
std::ofstream out(filename.toUtf8());
CGAL::output_surface_facets_to_off(out, c2t3);
if(!out)
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Export to the OFF file <tt>%1</tt> failed!").arg(filename));
status_message(tr("Export to the OFF file %1 failed!").arg(filename));
std::cerr << " failed!\n";
}
else
{
std::cerr << " done.\n";
status_message(tr("Successfull export to the OFF file %1.").arg(filename));
}
}
}
void Volume::save_image_to_inr()
{
QFileDialog filedialog(mw, tr("Export image to Inrimage format"));
filedialog.setFileMode(QFileDialog::AnyFile);
filedialog.setNameFilter(tr("Inrimage files (*.inr);;"
"Compressed Inrimage files (*.inr.gz)"));
filedialog.setAcceptMode(QFileDialog::AcceptSave);
filedialog.setDefaultSuffix("inr.gz");
if(filedialog.exec())
{
const QString filename = filedialog.selectedFiles().front();
std::cerr << "Saving image to file \"" << filename.toLocal8Bit().data() << "\"...";
const int result = ::_writeImage(m_image.image(), filename.toUtf8());
if(result != ImageIO_NO_ERROR)
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Export to the Inrimage file <tt>%1</tt> failed!").arg(filename));
status_message(tr("Export to the Inrimage file %1 failed!").arg(filename));
std::cerr << " failed!\n";
}
else
{
std::cerr << " done.\n";
status_message(tr("Successfull export to the Inrimage file %1.").arg(filename));
}
}
}
// Process one line of incoming serial data. Remove unneeded characters and capitalize.
void protocol_process()
{
uint8_t c;
while((c = serial_read()) != SERIAL_NO_DATA) {
if ((c == '\n') || (c == '\r')) { // End of line reached
// Runtime command check point before executing line. Prevent any furthur line executions.
// NOTE: If there is no line, this function should quickly return to the main program when
// the buffer empties of non-executable data.
protocol_execute_runtime();
if (sys.abort) { return; } // Bail to main program upon system abort
if (char_counter > 0) {// Line is complete. Then execute!
line[char_counter] = 0; // Terminate string
status_message(protocol_execute_line(line));
} else {
// Empty or comment line. Skip block.
status_message(STATUS_OK); // Send status message for syncing purposes.
}
char_counter = 0; // Reset line buffer index
iscomment = false; // Reset comment flag
} else {
if (iscomment) {
// Throw away all comment characters
if (c == ')') {
// End of comment. Resume line.
iscomment = false;
}
} else {
if (c <= ' ') {
// Throw away whitepace and control characters
} else if (c == '/') {
// Disable block delete and throw away characters. Will ignore until EOL.
#if BLOCK_DELETE_ENABLE
iscomment = true;
#endif
} else if (c == '(') {
// Enable comments flag and ignore all characters until ')' or EOL.
iscomment = true;
} else if (char_counter >= LINE_BUFFER_SIZE-1) {
// Throw away any characters beyond the end of the line buffer
} else if (c >= 'a' && c <= 'z') { // Upcase lowercase
line[char_counter++] = c-'a'+'A';
} else {
line[char_counter++] = c;
}
}
}
}
}
bool Volume::opendir(const QString& dirname)
{
bool result = true;
if(!fileinfo.isReadable())
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Cannot read directory <tt>%1</tt>!").arg(dirname));
status_message(tr("Opening of directory %1 failed!").arg(dirname));
result = false;
}
else
{
dicom_reader = vtkDICOMImageReader::New();
dicom_reader->SetDirectoryName(dirname.toUtf8());
executive =
vtkDemandDrivenPipeline::SafeDownCast(dicom_reader->GetExecutive());
if (executive)
{
executive->SetReleaseDataFlag(0, 0); // where 0 is the port index
}
smoother = vtkImageGaussianSmooth::New();
smoother->SetStandardDeviations(1., 1., 1.);
smoother->SetInputConnection(dicom_reader->GetOutputPort());
smoother->Update();
vtk_image = smoother->GetOutput();
vtk_image->Print(std::cerr);
m_image = CGAL::read_vtk_image_data(vtk_image);
if(m_image.image() == 0)
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Error with file <tt>%1/</tt>:\nunknown file format!").arg(dirname));
status_message(tr("Opening of file %1/ failed!").arg(dirname));
result = false;
}
else
{
status_message(tr("File %1/ successfully opened.").arg(dirname));
finish_open();
result = true;
}
// if(executive) executive->Delete();
// dicom_reader->Delete();
// smoother->Delete();
}
return result;
}
int
main(int argc, char *argv[]) {
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " url" << std::endl;
return 1;
}
try {
http::client client;
http::client::request request{network::uri{std::string{argv[1]}}};
request.version("1.0");
request.append_header("Connection", "close");
request.append_header("User-Agent", "cpp-netlib read_headers example");
auto future_response = client.head(request);
auto response = future_response.get();
std::cout << "HTTP version: " << response.version() << std::endl;
std::cout << "HTTP status: " << static_cast<int>(response.status()) << std::endl;
std::cout << "HTTP status message: " << response.status_message() << std::endl;
std::cout << std::endl;
for (auto header : response.headers()) {
std::cout << header.first << ": " << header.second << std::endl;
}
}
catch (std::exception& e) {
std::cerr << e.what() << std::endl;
return 1;
}
return 0;
}
void print_audio_devices_info(audio_device_t *d)
{
ao_info *info;
while (d != NULL) {
info = ao_driver_info(d->driver_id);
status_message(2, _("\nAudio Device: %s"), info->name);
status_message(3, _("Author: %s"), info->author);
status_message(3, _("Comments: %s"), info->comment);
status_message(2, "");
d = d->next_device;
}
}
bool Volume::open_vtk(const QString& filename)
{
only_in();
fileinfo.setFile(filename);
if(fileinfo.isDir())
{
return opendir(filename);
}
if(!fileinfo.isReadable())
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Cannot read file <tt>%1</tt>!").arg(filename));
status_message(tr("Opening of file %1 failed!").arg(filename));
return false;
}
else
{
vtk_reader = vtkImageReader::New();
vtk_reader->SetFileName(filename.toUtf8());
vtk_reader->SetDataScalarTypeToUnsignedChar();
vtk_reader->SetDataExtent(0, 249, 0, 249, 0, 124);
vtk_reader->SetDataSpacing(1., 1., 1.);
vtk_reader->SetFileDimensionality(3);
vtk_reader->Update();
vtk_reader->Print(std::cerr);
vtk_image = vtk_reader->GetOutput();
vtk_image->Print(std::cerr);
m_image = CGAL::read_vtk_image_data(vtk_image);
if(m_image.image() == NULL)
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Error with file <tt>%1</tt>:\nunknown file format!").arg(filename));
status_message(tr("Opening of file %1 failed!").arg(filename));
return false;
}
else
{
status_message(tr("File %1 successfully opened.").arg(filename));
finish_open();
return true;
}
}
}
void
chat::_handle_global_ignore(::message *msg) {
ACE_DEBUG((LM_DEBUG, "chat::_handle_global_ignore"));
message_global_ignore *m = dynamic_ptr_cast<message_global_ignore>(msg);
message_global_ignore::ip_list_type::const_iterator i = m->ip_begin();
bool first = true;
for (; i != m->ip_end(); i++) {
if (first) {
status_message(langstr("chat/global_ignore"));
first = false;
}
status_message(
langstr("chat/user_global_ignore",
i->userid.c_str(), i->reason.c_str())
);
}
}
// Process one line of incoming serial data. Remove unneeded characters and capitalize.
void protocol_process()
{
char c;
while((c = serial_read()) != SERIAL_NO_DATA)
{
if ((c == '\n') || (c == '\r')) { // End of line reached
if (char_counter > 0) {// Line is complete. Then execute!
line[char_counter] = 0; // Terminate string
status_message(protocol_execute_line(line));
} else {
// Empty or comment line. Skip block.
status_message(STATUS_OK); // Send status message for syncing purposes.
}
char_counter = 0; // Reset line buffer index
iscomment = false; // Reset comment flag
} else {
if (iscomment) {
// Throw away all comment characters
if (c == ')') {
// End of comment. Resume line.
iscomment = false;
}
} else {
if (c <= ' ') {
// Throw away whitepace and control characters
} else if (c == '/') {
// Disable block delete and throw away character
// To enable block delete, uncomment following line. Will ignore until EOL.
// iscomment = true;
} else if (c == '(') {
// Enable comments flag and ignore all characters until ')' or EOL.
iscomment = true;
} else if (char_counter >= LINE_BUFFER_SIZE-1) {
// Throw away any characters beyond the end of the line buffer
} else if (c >= 'a' && c <= 'z') { // Upcase lowercase
line[char_counter++] = c-'a'+'A';
} else {
line[char_counter++] = c;
}
}
}
}
}
bool Volume::opendir(const QString& dirname)
{
bool result = true;
if(!fileinfo.isReadable())
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Cannot read directory <tt>%1</tt>!").arg(dirname));
status_message(tr("Opening of directory %1 failed!").arg(dirname));
result = false;
}
else
{
vtkDICOMImageReader* dicom_reader = vtkDICOMImageReader::New();
dicom_reader->SetDirectoryName(dirname.toUtf8());
vtkImageGaussianSmooth* smoother = vtkImageGaussianSmooth::New();
smoother->SetStandardDeviations(1., 1., 1.);
smoother->SetInputConnection(dicom_reader->GetOutputPort());
smoother->Update();
vtkImageData* vtk_image = smoother->GetOutput();
dicom_reader->SetReleaseDataFlag(false);
vtk_image->SetReleaseDataFlag(false);
vtk_image->Print(std::cerr);
if(!m_image.read_vtk_image_data(vtk_image))
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Error with file <tt>%1/</tt>:\nunknown file format!").arg(dirname));
status_message(tr("Opening of file %1/ failed!").arg(dirname));
result = false;
}
else
{
status_message(tr("File %1/ successfully opened.").arg(dirname));
finish_open();
result = true;
}
dicom_reader->Delete();
// smoother->Delete();
}
return result;
}
void sp_process()
{
char c;
while((c = serialRead()) != -1)
{
if((char_counter > 0) && ((c == '\n') || (c == '\r'))) { // Line is complete. Then execute!
line[char_counter] = 0; // treminate string
status_message(gc_execute_line(line));
char_counter = 0; // reset line buffer index
} else if (c <= ' ') { // Throw away whitepace and control characters
} else if (c >= 'a' && c <= 'z') { // Upcase lowercase
line[char_counter++] = c-'a'+'A';
} else {
line[char_counter++] = c;
}
}
}
/*
* FILEVIEW CALLBACKS
*/
static void
updir_click_cb(GtkWidget *widget, GdkEventButton *event, FileView *view)
{
if (event->button == 1)
{
gchar path[PATH_MAX];
g_snprintf(path, sizeof(path), "%s/..", view->dir);
change_dir(view, path);
}
else if (event->button == 3)
{
gchar *home;
if ((home = getenv("HOME")) != NULL)
change_dir(view, home);
else
status_message(_("Environment variable 'HOME' not set."));
}
gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "button_press_event");
focus_row(view, view->row, TRUE, TRUE, TRUE);
}
QMSMMainWindow::QMSMMainWindow(QWidget* pParent, NData::CDataHandler& rDataHandler, QApplication* pApplication) :
QMainWindow(pParent),
MainWindow(),
mpApplication(pApplication),
mpFormInfo(0),
mpFormSettings(0),
mpFormSystemOverview(0),
mrDataHandler(rDataHandler),
mpFormPower(0),
mpFormTemperature(0),
mpFormClock(0),
mpFormUtilization(0),
mpFormMemory(0),
mpFormHeatmapUtilization(0),
mpFormHeatmapTemperature(0),
mGuiMarker(this)
{
setupUi(this);
QString windowTitleKey = "MSMonitor v";
windowTitleKey += QString::number(MS_MAJOR_VERSION);
windowTitleKey += ".";
windowTitleKey += QString::number(MS_MINOR_VERSION);
windowTitleKey += ".";
windowTitleKey += QString::number(MS_REVISION_VERSION);
setWindowTitle(QApplication::translate("MainWindow", qPrintable(windowTitleKey), 0, QApplication::UnicodeUTF8));
mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
pushButtonStop->setEnabled(false);
createActions();
createShortcuts();
mpFormInfo = QMSMFormInfo::construct(this);
mpFormSettings = QMSMFormSettings::construct(this, mrDataHandler.getSettings());
mpFormSystemOverview = QMSMFormSystemOverview::construct(this, &mrDataHandler);
mpFormPower = QMSMFormPower::construct(this, &mrDataHandler);
mpFormTemperature = QMSMFormTemperature::construct(this, &mrDataHandler);
mpFormClock = QMSMFormClock::construct(this, &mrDataHandler);
mpFormUtilization = QMSMFormUtilization::construct(this, &mrDataHandler);
mpFormMemory = QMSMFormMemory::construct(this, &mrDataHandler);
mpFormHeatmapUtilization = QMSMFormHeatmapUtilization::construct(this, &mrDataHandler);
mpFormHeatmapTemperature = QMSMFormHeatmapTemperature::construct(this, &mrDataHandler);
mdiArea->addSubWindow(mpFormInfo);
mdiArea->addSubWindow(mpFormSettings);
mdiArea->addSubWindow(mpFormSystemOverview);
mdiArea->addSubWindow(mpFormPower);
mdiArea->addSubWindow(mpFormTemperature);
mdiArea->addSubWindow(mpFormClock);
mdiArea->addSubWindow(mpFormUtilization);
mdiArea->addSubWindow(mpFormMemory);
mdiArea->addSubWindow(mpFormHeatmapUtilization);
mdiArea->addSubWindow(mpFormHeatmapTemperature);
mpFormInfo->hide();
mpFormSettings->hide();
mpFormSystemOverview->hide();
mpFormPower->hide();
mpFormTemperature->hide();
mpFormClock->hide();
mpFormUtilization->hide();
mpFormMemory->hide();
mpFormHeatmapUtilization->hide();
mpFormHeatmapTemperature->hide();
QString status_message("Listening on socket \"");
status_message += mGuiMarker.getSocketName();
status_message += "\".";
QLabel status_label(status_message);
statusBar()->addPermanentWidget(&status_label);
show();
statusbar->showMessage(status_message);
}
//********************************************************************
void find_anagrams(HWND hwnd)
{
char msgstr[81] ;
// read data out of hwnd:IDC_PHRASE
char input_bfr[MAX_PKT_CHARS+1] ;
uint input_bfr_len = GetWindowTextA (GetDlgItem(hwnd,IDC_PHRASE) , input_bfr, MAX_PKT_CHARS);
if (input_bfr_len > MAX_PKT_CHARS)
input_bfr_len = MAX_PKT_CHARS ;
input_bfr[MAX_PKT_CHARS] = 0 ;
if (vflag) //lint !e506 !e774
syslog("find_anagrams: [%u] [%s]\n", input_bfr_len, input_bfr) ;
// scan for separator char
excl_idx = 0 ; // reset exclusions list
char *hd ;
char *tl = strchr(input_bfr, '!');
if (tl != NULL) {
*tl++ = 0 ; // NULL-term word list, point to exclusions list
while (LOOP_FOREVER) {
tl = strip_leading_spaces(tl);
if (*tl != 0) {
hd = tl ;
tl = strchr(hd, ' ');
if (tl != NULL) {
*tl++ = 0 ;
// hd points to one exclusion arg
}
add_to_excl_list(hd);
if (tl == NULL) {
break;
}
}
}
}
status_message("Begin new anagram search") ;
// clear_message_area(&this_term);
clear_message_area();
if (excl_idx == 0) {
status_message("excl: <none>", 1);
}
else
{
uint slen = sprintf(msgstr, "excl: ");
for (uint idx=0; idx<excl_idx; idx++) {
slen += (uint) sprintf(msgstr+slen, "%s ", excl_list[idx]);
}
status_message(msgstr, 1);
}
delete_wordlist() ;
ZeroMemory((char *) &freq[0], sizeof(freq)) ;
nletters = 0 ;
for (char *p = input_bfr; *p != 0; p++) {
if (*p != ' ') {
freq[(uint) (u8) *p]++ ;
nletters++;
}
}
if (maxgen == 0)
maxgen = nletters;
wordlist = buildwordlist ();
if (wordlist == NULL) {
syslog("Empty dictionary or no suitable words.\n");
return ;
}
wordlist = sort (wordlist);
initfind (wordlist);
solutions_found = 0 ;
findanags (0, forgelinks (wordlist), nletters);
if (solutions_found == 0) {
status_message("no anagrams found for input string !") ;
} else {
// reverse_list_entries() ;
// InsertListViewItems(solutions_found); // This triggers drawing of listview
myTerminal->reverse_list_entries() ;
update_listview();
wsprintf(msgstr, "%u anagrams found", solutions_found) ;
status_message(msgstr) ;
}
}
void Volume::display_surface_mesher_result()
{
if(m_surface.empty() || // Either the surface is not computed.
m_view_surface) // Or it is computed and displayed, and one want
// to recompute it.
{
QTime total_time;
total_time.start();
values_list->save_values(fileinfo.absoluteFilePath());
std::size_t nx = m_image.xdim();
std::size_t ny = m_image.ydim();
std::size_t nz = m_image.zdim();
if(nx * ny * nz == 0)
{
status_message("No volume loaded.");
return;
}
m_surface.clear();
sm_timer.reset();
busy();
status_message("Surface meshing...");
sm_timer.start();
c2t3.clear();
del.clear();
Sphere bounding_sphere(m_image.center(),m_image.radius()*m_image.radius());
Classify_from_isovalue_list classify(values_list);
Generate_surface_identifiers generate_ids(values_list);
m_image.set_interpolation(mw->interpolationCheckBox->isChecked());
if(mw->labellizedRadioButton->isChecked()) {
std::cerr << "Labellized image\n";
}
m_image.set_labellized(mw->labellizedRadioButton->isChecked());
classify.set_identity(mw->labellizedRadioButton->isChecked());
generate_ids.set_labellized_image(mw->labellizedRadioButton->isChecked());
// definition of the surface
Surface_3 surface(m_image, bounding_sphere, m_relative_precision);
// Threshold threshold(m_image.isovalue());
// surface mesh traits class
typedef CGAL::Surface_mesher::Implicit_surface_oracle_3<Kernel,
// typedef CGAL::Surface_mesher::Image_surface_oracle_3<Kernel,
Surface_3,
Classify_from_isovalue_list,
Generate_surface_identifiers> Oracle;
Oracle oracle(classify, generate_ids);
if(mw->searchSeedsCheckBox->isChecked())
{
typedef std::vector<std::pair<Point, double> > Seeds;
Seeds seeds;
{
std::cerr << "Search seeds...\n";
std::set<unsigned char> domains;
search_for_connected_components(std::back_inserter(seeds),
CGAL::inserter(domains),
classify);
std::cerr << "Found " << seeds.size() << " seed(s).\n";
if(mw->labellizedRadioButton->isChecked() &&
values_list->numberOfValues() == 0)
{
Q_FOREACH(unsigned char label, domains) {
if(label != 0) {
values_list->addValue(label);
}
}
}
}
std::ofstream seeds_out("seeds.off");
std::ofstream segments_out("segments.txt");
seeds_out.precision(18);
seeds_out << "OFF\n" << seeds.size() << " 0 0\n";
segments_out.precision(18);
for(Seeds::const_iterator it = seeds.begin(), end = seeds.end();
it != end; ++it)
{
seeds_out << it->first << std::endl;
CGAL::Random_points_on_sphere_3<Point> random_points_on_sphere_3(it->second);
Oracle::Intersect_3 intersect = oracle.intersect_3_object();
for(int i = 0; i < 20; ++i)
{
const Point test = it->first + (*random_points_on_sphere_3++ - CGAL::ORIGIN);
CGAL::Object o = intersect(surface, Segment_3(it->first, test));
if (const Point* intersection = CGAL::object_cast<Point>(&o)) {
segments_out << "2 " << it->first << " " << *intersection << std::endl;
del.insert(*intersection);
}
else
{
std::cerr <<
boost::format("Error. Segment (%1%, %2%) does not intersect the surface! values=(%3%, %4%)\n")
% it->first % test
% surface(it->first) % surface(test);
}
}
}
}
static
VALUE rhe_write_response(VALUE self, VALUE filenov, VALUE timeoutv, VALUE status_codev, VALUE headers, VALUE body) {
ssize_t hlen;
ssize_t blen;
ssize_t len;
ssize_t rv = 0;
ssize_t iovcnt;
ssize_t vec_offset;
ssize_t written;
int count;
int i;
char status_line[512];
char date_line[512];
int date_pushed = 0;
VALUE arr;
VALUE key_obj;
VALUE val_obj;
char * key;
int fileno = NUM2INT(filenov);
double timeout = NUM2DBL(timeoutv);
int status_code = NUM2INT(status_codev);
arr = rb_ary_new();
rb_hash_foreach(headers, my_hash_keys, arr);
hlen = RARRAY_LEN(arr);
blen = RARRAY_LEN(body);
iovcnt = 10 + (hlen * 2) + blen;
{
struct iovec v[iovcnt]; // Needs C99 compiler
/* status line */
iovcnt = 0;
i=0;
status_line[i++] = 'H';
status_line[i++] = 'T';
status_line[i++] = 'T';
status_line[i++] = 'P';
status_line[i++] = '/';
status_line[i++] = '1';
status_line[i++] = '.';
status_line[i++] = '0';
status_line[i++] = ' ';
str_i(status_line,&i,status_code,3);
status_line[i++] = ' ';
const char * message = status_message(status_code);
str_s(status_line, &i, message, strlen(message));
status_line[i++] = 13;
status_line[i++] = 10;
v[iovcnt].iov_base = status_line;
v[iovcnt].iov_len = i;
iovcnt++;
v[iovcnt].iov_base = "Connection: close\r\nServer: Rhebok\r\n";
v[iovcnt].iov_len = sizeof("Connection: close\r\nServer: Rhebok\r\n")-1;
iovcnt++;
date_pushed = 0;
for ( i = 0; i < hlen; i++ ) {
key_obj = rb_ary_entry(arr, i);
key = StringValuePtr(key_obj);
len = RSTRING_LEN(key_obj);
if ( strncasecmp(key,"Connection",len) == 0 ) {
continue;
}
if ( strncasecmp(key,"Server",len) == 0 ) {
v[1].iov_len -= (sizeof("Server: Rhebok\r\n") - 1);
}
if ( strncasecmp(key,"Date",len) == 0 ) {
date_pushed = 1;
}
v[iovcnt].iov_base = key;
v[iovcnt].iov_len = len;
iovcnt++;
v[iovcnt].iov_base = ": ";
v[iovcnt].iov_len = sizeof(": ") - 1;
iovcnt++;
/* value */
val_obj = rb_hash_aref(headers, key_obj);
v[iovcnt].iov_base = StringValuePtr(val_obj);
v[iovcnt].iov_len = RSTRING_LEN(val_obj);
iovcnt++;
v[iovcnt].iov_base = "\r\n";
v[iovcnt].iov_len = sizeof("\r\n") - 1;
iovcnt++;
}
if ( date_pushed == 0 ) {
v[iovcnt].iov_len = _date_line(date_line);
v[iovcnt].iov_base = date_line;
iovcnt++;
}
v[iovcnt].iov_base = "\r\n";
v[iovcnt].iov_len = sizeof("\r\n") - 1;
iovcnt++;
for (i=0; i < blen; i++ ) {
val_obj = rb_ary_entry(body, i);
v[iovcnt].iov_base = StringValuePtr(val_obj);
v[iovcnt].iov_len = RSTRING_LEN(val_obj);
iovcnt++;
}
vec_offset = 0;
written = 0;
while ( iovcnt - vec_offset > 0 ) {
count = (iovcnt > IOV_MAX) ? IOV_MAX : iovcnt;
rv = _writev_timeout(fileno, timeout, &v[vec_offset], count - vec_offset, (vec_offset == 0) ? 0 : 1);
if ( rv <= 0 ) {
// error or disconnected
break;
}
written += rv;
while ( rv > 0 ) {
if ( (int)rv >= v[vec_offset].iov_len ) {
rv -= v[vec_offset].iov_len;
vec_offset++;
}
else {
v[vec_offset].iov_base = (char*)v[vec_offset].iov_base + rv;
v[vec_offset].iov_len -= rv;
rv = 0;
}
}
}
}
if ( rv < 0 ) {
return Qnil;
}
return rb_int_new(written);
}
void
chat::handle_message(::message *msg) {
switch (msg->id()) {
case ::message::send:
case ::message::send_private:
{
message_channel *m = dynamic_ptr_cast<message_channel>(msg);
ACE_DEBUG((LM_DEBUG, "chat::handle message _channel/channel %s/%s\n",
_channel.c_str(), m->channel().c_str()));
if (_channel == m->channel()) {
// Public message
public_message(m->sender_id(), m->str(), m->group_base());
}
}
break;
case ::message::private_refused:
{
message_channel *m = dynamic_ptr_cast<message_channel>(msg);
ACE_DEBUG((LM_DEBUG, "chat::handle message _channel/channel %s/%s\n",
_channel.c_str(), m->channel().c_str()));
if (_channel == m->channel()) {
// Status message of refused
status_message(
langstr("chat/private_msg_refused", m->str().c_str())
);
}
}
break;
case ::message::send_notification:
{
message_channel *m = dynamic_ptr_cast<message_channel>(msg);
ACE_DEBUG((LM_DEBUG, "chat::handle message _channel/channel %s/%s\n",
_channel.c_str(), m->channel().c_str()));
if (_channel == m->channel()) {
notification_message(
m->sender_id(), m->str(), m->group_base()
);
}
}
break;
case ::message::block_users:
{
message_block_users *m = dynamic_ptr_cast<message_block_users>(msg);
if (m->global_ignore() == false) {
ACE_DEBUG((LM_DEBUG, "chat::handle message block_users\n"));
status_message(
langstr("chat/user_ignores", m->user().display_id().c_str())
);
}
}
break;
case ::message::global_ignore_list:
_handle_global_ignore(msg);
break;
case ::message::room:
{
message_room *m = dynamic_ptr_cast<message_room>(msg);
const chat_gaming::room &r = m->room();
if (app_opts.debug()) {
std::string msgstr =
"Room update id " + (const std::string)r.id() +
" topic " + r.topic() +
" owner id " + (const std::string)(r.owner_id());
status_message(msgstr);
}
}
break;
case ::message::user:
{
message_user *m = dynamic_ptr_cast<message_user>(msg);
const chat_gaming::user &u = m->user();
if (app_opts.debug()) {
std::string msgstr =
"User update id " + (std::string)u.id() +
" in room id " + (std::string)u.room_id();
status_message(msgstr);
}
}
break;
}
}
void Volume::display_marchin_cube()
{
#ifdef CGAL_SURFACE_MESH_DEMO_USE_MARCHING_CUBE
if(m_surface_mc.empty())
{
QTime total_time;
total_time.start();
values_list->save_values(fileinfo.absoluteFilePath());
unsigned int nx = m_image.xdim();
unsigned int ny = m_image.ydim();
unsigned int nz = m_image.zdim();
if(nx * ny * nz == 0)
{
status_message("No volume loaded.");
return;
}
mc_timer.reset();
busy();
status_message("Marching cubes...");
mc_timer.start();
m_surface_mc.clear();
if(mc.ntrigs()!=0)
mc.clean_all();
mc.set_resolution(nx,ny,nz);
mc.init_all();
mc.set_ext_data(static_cast<unsigned char*>(m_image.image()->data));
nbs_of_mc_triangles.resize(values_list->numberOfValues());
for(int value_id = 0;
value_id < values_list->numberOfValues();
++value_id)
{
status_message(tr("Marching cubes, isovalue #%1...").arg(value_id));
// set data
// for(unsigned int i=0;i<nx;i++)
// for(unsigned int j=0;j<ny;j++)
// for(unsigned int k=0;k<nz;k++)
// {
// const float& value = m_image.value(i,j,k);
// mc.set_data(value,i,j,k);
// }
// compute scaling ratio
if(value_id > 0)
mc.init_temps();
mc.run(values_list->value(value_id),
m_image.vx(),
m_image.vy(),
m_image.vz());
mc.clean_temps();
std::vector<double> facets;
mc.get_facets(facets);
mc_timer.stop();
const unsigned int begin = value_id == 0 ? 0 : nbs_of_mc_triangles[value_id-1];
const unsigned int nbt = facets.size() / 9;
for(unsigned int i=begin;i<nbt;i++)
{
const Point a(facets[9*i], facets[9*i+1], facets[9*i+2]);
const Point b(facets[9*i+3], facets[9*i+4], facets[9*i+5]);
const Point c(facets[9*i+6], facets[9*i+7], facets[9*i+8]);
const Triangle_3 t(a,b,c);
const Vector u = t[1] - t[0];
const Vector v = t[2] - t[0];
Vector n = CGAL::cross_product(u,v);
n = n / std::sqrt(n*n);
m_surface_mc.push_back(Facet(t,n,values_list->item(value_id)));
}
nbs_of_mc_triangles[value_id]=m_surface_mc.size();
mc_timer.start();
}
mc_timer.stop();
not_busy();
mc_total_time = total_time.elapsed();
// invalidate the display list
lists_draw_surface_mc_is_valid = false;
list_draw_marching_cube_is_valid = false;
}
CGAL::Bbox_3 bbox(0,0,0,0,0,0);
for(std::vector<Facet>::const_iterator
it = m_surface_mc.begin(), end = m_surface_mc.end();
it != end; ++it)
{
bbox = bbox + it->get<0>().bbox();
}
m_view_mc = true;
m_view_surface = false;
Q_EMIT changed();
if(!m_surface_mc.empty())
{
Q_EMIT new_bounding_box(bbox.xmin(),
bbox.ymin(),
bbox.zmin(),
bbox.xmax(),
bbox.ymax(),
bbox.zmax());
}
status_message(tr("Marching cubes done. %2 facets in %1s (CPU time), total time is %3s.")
.arg(mc_timer.time())
.arg(m_surface_mc.size())
.arg(mc_total_time/1000.));
save_image_settings(fileinfo.absoluteFilePath());
#endif // CGAL_SURFACE_MESH_DEMO_USE_MARCHING_CUBE
}
void play (char *source_string)
{
transport_t *transport;
format_t *format;
data_source_t *source;
decoder_t *decoder;
decoder_callbacks_t decoder_callbacks;
void *decoder_callbacks_arg;
/* Preserve between calls so we only open the audio device when we
have to */
static audio_format_t old_audio_fmt = { 0, 0, 0, 0, 0 };
audio_format_t new_audio_fmt;
audio_reopen_arg_t *reopen_arg;
/* Flags and counters galore */
int eof = 0, eos = 0, ret;
int nthc = 0, ntimesc = 0;
int next_status = 0;
static int status_interval = 0;
/* Reset all of the signal flags */
sig_request.cancel = 0;
sig_request.skipfile = 0;
sig_request.exit = 0;
sig_request.pause = 0;
/* Set preferred audio format (used by decoder) */
new_audio_fmt.big_endian = ao_is_big_endian();
new_audio_fmt.signed_sample = 1;
new_audio_fmt.word_size = 2;
/* Select appropriate callbacks */
if (audio_buffer != NULL) {
decoder_callbacks.printf_error = &decoder_buffered_error_callback;
decoder_callbacks.printf_metadata = &decoder_buffered_metadata_callback;
decoder_callbacks_arg = audio_buffer;
} else {
decoder_callbacks.printf_error = &decoder_error_callback;
decoder_callbacks.printf_metadata = &decoder_metadata_callback;
decoder_callbacks_arg = NULL;
}
/* Locate and use transport for this data source */
if ( (transport = select_transport(source_string)) == NULL ) {
status_error(_("No module could be found to read from %s.\n"), source_string);
return;
}
if ( (source = transport->open(source_string, &options)) == NULL ) {
status_error(_("Cannot open %s.\n"), source_string);
return;
}
/* Detect the file format and initialize a decoder */
if ( (format = select_format(source)) == NULL ) {
status_error(_("The file format of %s is not supported.\n"), source_string);
return;
}
if ( (decoder = format->init(source, &options, &new_audio_fmt,
&decoder_callbacks,
decoder_callbacks_arg)) == NULL ) {
/* We may have failed because of user command */
if (!sig_request.cancel)
status_error(_("Error opening %s using the %s module."
" The file may be corrupted.\n"), source_string,
format->name);
return;
}
/* Decide which statistics are valid */
select_stats(stat_format, &options, source, decoder, audio_buffer);
/* Start the audio playback thread before we begin sending data */
if (audio_buffer != NULL) {
/* First reset mutexes and other synchronization variables */
buffer_reset (audio_buffer);
buffer_thread_start (audio_buffer);
}
/* Show which file we are playing */
decoder_callbacks.printf_metadata(decoder_callbacks_arg, 1,
_("Playing: %s"), source_string);
/* Skip over audio */
if (options.seekpos > 0.0) {
if (!format->seek(decoder, options.seekpos, DECODER_SEEK_START)) {
status_error(_("Could not skip %f seconds of audio."), options.seekpos);
if (audio_buffer != NULL)
buffer_thread_kill(audio_buffer);
return;
}
}
/* Main loop: Iterates over all of the logical bitstreams in the file */
while (!eof && !sig_request.exit) {
/* Loop through data within a logical bitstream */
eos = 0;
while (!eos && !sig_request.exit) {
/* Check signals */
if (sig_request.skipfile) {
eof = eos = 1;
break;
}
if (sig_request.pause) {
if (audio_buffer)
buffer_thread_pause (audio_buffer);
kill (getpid(), SIGSTOP); /* We block here until we unpause */
/* Done pausing */
if (audio_buffer)
buffer_thread_unpause (audio_buffer);
sig_request.pause = 0;
}
/* Read another block of audio data */
ret = format->read(decoder, convbuffer, convsize, &eos, &new_audio_fmt);
/* Bail if we need to */
if (ret == 0) {
eof = eos = 1;
break;
} else if (ret < 0) {
status_error(_("Error: Decoding failure.\n"));
break;
}
/* Check to see if the audio format has changed */
if (!audio_format_equal(&new_audio_fmt, &old_audio_fmt)) {
old_audio_fmt = new_audio_fmt;
/* Update our status printing interval */
status_interval = new_audio_fmt.word_size * new_audio_fmt.channels *
new_audio_fmt.rate / options.status_freq;
next_status = 0;
reopen_arg = new_audio_reopen_arg(options.devices, &new_audio_fmt);
if (audio_buffer)
buffer_insert_action_at_end(audio_buffer, &audio_reopen_action,
reopen_arg);
else
audio_reopen_action(NULL, reopen_arg);
}
/* Update statistics display if needed */
if (next_status <= 0) {
display_statistics(stat_format, audio_buffer, source, decoder);
next_status = status_interval;
} else
next_status -= ret;
if (options.endpos > 0.0 && options.endpos <= current_time(decoder)) {
eof = eos = 1;
break;
}
/* Write audio data block to output, skipping or repeating chunks
as needed */
do {
if (nthc-- == 0) {
if (audio_buffer)
buffer_submit_data(audio_buffer, convbuffer, ret);
else
audio_play_callback(convbuffer, ret, eos, &audio_play_arg);
nthc = options.nth - 1;
}
} while (!sig_request.exit && !sig_request.skipfile &&
++ntimesc < options.ntimes);
ntimesc = 0;
} /* End of data loop */
} /* End of logical bitstream loop */
/* Done playing this logical bitstream. Clean up house. */
if (audio_buffer) {
if (!sig_request.exit && !sig_request.skipfile) {
buffer_mark_eos(audio_buffer);
buffer_wait_for_empty(audio_buffer);
}
buffer_thread_kill(audio_buffer);
}
/* Print final stats */
display_statistics_quick(stat_format, audio_buffer, source, decoder);
format->cleanup(decoder);
transport->close(source);
status_reset_output_lock(); /* In case we were killed mid-output */
status_message(1, _("Done."));
if (sig_request.exit)
exit (0);
}
bool Volume::open(const QString& filename)
{
only_in();
fileinfo.setFile(filename);
if(fileinfo.isDir())
{
return opendir(filename);
}
if(!fileinfo.isReadable())
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Cannot read file <tt>%1</tt>!").arg(filename));
}
else
{
if(m_image.read(filename.toStdString().c_str()))
{
status_message(tr("File %1 successfully opened.").arg(filename));
finish_open();
return true;
}
else if(open_xt(filename)) {
return true;
}
else
{
QSettings settings;
settings.beginGroup(QUrl::toPercentEncoding(fileinfo.absoluteFilePath()));
if( settings.value("is_raw").toBool() &&
m_image.read_raw(filename.toStdString().c_str(),
settings.value("dim_x").toInt(),
settings.value("dim_y").toInt(),
settings.value("dim_z").toInt(),
settings.value("spacing_x").toDouble(),
settings.value("spacing_y").toDouble(),
settings.value("spacing_z").toDouble(),
settings.value("offset").toInt()) )
{
status_message(tr("File %1 successfully opened.").arg(filename));
finish_open();
return true;
}
else if(QMessageBox::warning(mw, mw->windowTitle(),
tr("Error with file <tt>%1</tt>:\n"
"unknown file format!\n"
"\n"
"Open it as a raw image?").arg(filename),
QMessageBox::Yes|QMessageBox::No) == QMessageBox::Yes)
{
Raw_image_dialog raw_dialog;
raw_dialog.label_file_size->setText(QString("%1 B").arg(fileinfo.size()));
if( raw_dialog.exec() &&
m_image.read_raw(filename.toStdString().c_str(),
raw_dialog.dim_x->value(),
raw_dialog.dim_y->value(),
raw_dialog.dim_z->value(),
raw_dialog.spacing_x->value(),
raw_dialog.spacing_y->value(),
raw_dialog.spacing_z->value(),
raw_dialog.offset->value()) )
{
status_message(tr("File %1 successfully opened.").arg(filename));
QSettings settings;
settings.beginGroup(QUrl::toPercentEncoding(fileinfo.absoluteFilePath()));
settings.setValue("is_raw", true);
settings.setValue("dim_x", raw_dialog.dim_x->value());
settings.setValue("dim_y", raw_dialog.dim_y->value());
settings.setValue("dim_z", raw_dialog.dim_z->value());
settings.setValue("spacing_x", raw_dialog.spacing_x->value());
settings.setValue("spacing_y", raw_dialog.spacing_y->value());
settings.setValue("spacing_z", raw_dialog.spacing_z->value());
settings.setValue("offset", raw_dialog.offset->value());
settings.endGroup();
finish_open();
return true;
}
}
}
}
status_message(tr("Opening of file %1 failed!").arg(filename));
return false;
}
// Total 3D images (XT format, that is the old Inrimage format, 1994.
bool Volume::open_xt(const QString& filename)
{
only_in();
fileinfo.setFile(filename);
if(fileinfo.isDir())
{
return false;
}
if(!fileinfo.isReadable())
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Cannot read file <tt>%1</tt>!").arg(filename));
status_message(tr("Opening of file %1 failed!").arg(filename));
return false;
}
else
{
long dimx, dimy, dimz;
long word_dim;
long header_size;
const char* filename_stl = qPrintable(filename);
CGAL::Total::lire_longueur_entete(filename_stl, &header_size);
CGAL::Total::lire_nb_octet(filename_stl, &word_dim);
CGAL::Total::lire_longueur_trace(filename_stl, &dimx);
CGAL::Total::lire_nb_trace(filename_stl, &dimy);
CGAL::Total::lire_nb_plan(filename_stl, &dimz);
vtkImageReader* vtk_reader = vtkImageReader::New();
vtk_reader->SetFileName(filename_stl);
switch(word_dim) {
case 8:
vtk_reader->SetDataScalarTypeToUnsignedChar();
break;
case 16:
vtk_reader->SetDataScalarTypeToUnsignedShort();
break;
default:
return false;
}
vtk_reader->SetHeaderSize(header_size);
vtk_reader->SetDataExtent(1, dimx, 1, dimy, 1, dimz);
vtk_reader->SetDataSpacing(1., 1., 1.);
vtk_reader->SetFileDimensionality(3);
vtk_reader->Update();
vtk_reader->Print(std::cerr);
vtkImageData* vtk_image = vtk_reader->GetOutput();
vtk_image->Print(std::cerr);
m_image = CGAL::read_vtk_image_data(vtk_image);
if(m_image.image() != NULL)
{
QMessageBox::warning(mw, mw->windowTitle(),
tr("Error with file <tt>%1</tt>:\nunknown file format!").arg(filename));
status_message(tr("Opening of file %1 failed!").arg(filename));
return false;
}
else
{
status_message(tr("File %1 successfully opened.").arg(filename));
finish_open();
}
return true;
}
}
void MainWindow::simulationStateChanged()
{
MainController::state_t new_state = mController.getSimulationState();
QString status_message("");
switch(new_state) {
case MainController::RUNNING:
/* Control buttons */
ui->playButton->setText("Pause");
ui->playButton->setEnabled(true);
ui->stopButton->setEnabled(true);
/* Menubar actions */
ui->actionStart->setEnabled(false);
ui->actionStop->setEnabled(true);
/* Update status bar */
status_message = tr("Running: ");
status_message += mController.getSimulationFilePath();
mStatusLabel->setText(status_message);
break;
case MainController::ON_HOLD:
/* Control buttons */
ui->playButton->setText("Play");
ui->playButton->setEnabled(true);
ui->stopButton->setEnabled(true);
/* Menubar actions */
ui->actionStart->setEnabled(true);
ui->actionStop->setEnabled(true);
/* Update status bar */
status_message = tr("On hold: ");
status_message += mController.getSimulationFilePath();
mStatusLabel->setText(status_message);
break;
case MainController::WAITING_FOR_THREAD:
/* Control buttons */
ui->playButton->setText("Play");
ui->playButton->setEnabled(false);
ui->stopButton->setEnabled(false);
/* Menubar actions */
ui->actionStart->setEnabled(false);
ui->actionStop->setEnabled(false);
/* Update status bar */
status_message = tr("Waiting for simulation thread: ");
status_message += mController.getSimulationFilePath();
mStatusLabel->setText(status_message);
break;
case MainController::UNINITIALIZED:
ui->playButton->setText("Play");
ui->playButton->setEnabled(false);
ui->stopButton->setEnabled(false);
/* Menubar actions */
ui->actionStop->setEnabled(false);
ui->actionStart->setEnabled(false);
ui->objectList->clear();
/* Update status bar */
status_message = tr("Uninitialized");
mStatusLabel->setText(status_message);
if(mIsTerminated) {
close();
}
break;
case MainController::INITIALIZED:
load_simulation_objects();
ui->playButton->setText("Play");
ui->playButton->setEnabled(true);
ui->stopButton->setEnabled(true);
/* Menubar actions */
ui->actionStop->setEnabled(true);
ui->actionStart->setEnabled(true);
/* Update status bar */
status_message = tr("Initialized: ");
status_message += mController.getSimulationFilePath();
mStatusLabel->setText(status_message);
break;
default:
break;
}
}
// Main deals with checking all the devices and arguments.
// It will call another function to do the actual work.
int main(int argc,char *argv[]){
//variables
int device_num = 0;
int error = Pa_Initialize();
int i = 0;
int arg_data_count = 0;
bool audio_get_list = false;
bool input_wanted = false;
int device_chosen = 0;
const PaDeviceInfo *device_info;
char user_select_device[8];
PaStreamParameters input_stream_param;
// Parse arguments
if(argc >= 1){
for(i = 0;i < argc;i++){
if(arg_data_count == 0){
// Prints a list of all audio devices.
if(strcmp(argv[i],"-list") == 0){
audio_get_list = true;
}
// Same as -list, but lets you select which one you use.
if(strcmp(argv[i],"-input") == 0){
audio_get_list = true;
input_wanted = true;
}
} else {
arg_data_count = arg_data_count-1;
}
}
}
/// Init
status_message(stat_general,"SoundScale");
status_message(stat_general,"Using PortAudio Version:");
status_message(stat_general,(char *) Pa_GetVersionText());
// Checks for PA and audio devices.
if(error != paNoError){
status_message(stat_critical,"PA DID NOT INITIALISE");
return PA_INIT_FAIL;
} else {
status_message(stat_general,"PA INITIALIZED");
}
device_num = Pa_GetDeviceCount();
if(device_num < 0){
status_message(stat_critical,"ERROR - NO AUDIO DEVICES");
return NO_AUDIO_DEVICES;
}
// Audio Device selection. This can be cleaned up.
if(audio_get_list == true){
printf("[*] Discovered %i Audio devices\n",device_num);
for(i = 0; i < device_num;i++){
device_info = Pa_GetDeviceInfo(i);
printf("[*] [%i] %s \n",i,device_info->name);
}
if(input_wanted == true){
printf("[*] Please select input: ");
scanf("%s",user_select_device);
if(atoi(user_select_device) < device_num && atoi(user_select_device) >= 0){
device_chosen = atoi(user_select_device);
input_stream_param.device = device_chosen;
} else {
// Maybe ask user?
input_stream_param.device = device_chosen = Pa_GetDefaultInputDevice();
}
} else if(input_wanted == false){
return SUCCESS;
}
} else {
if(device_chosen > 0 && device_chosen <= device_num){
input_stream_param.device = device_chosen;
} else {
input_stream_param.device = Pa_GetDefaultInputDevice();
if(input_stream_param.device == paNoDevice){
status_message(stat_critical,"NO DEFAULT INPUT DEVICE, EXITING");
return FAILURE;
}
}
}
status_message(stat_general,"Using device:");
device_info = Pa_GetDeviceInfo(input_stream_param.device);
status_message(stat_general,(char *)device_info->name);
return SUCCESS;
}
