void DATA_TF_CLASS::setTsCode(TS_CODE tsCode, string transferSyntax)
// DESCRIPTION : Set the transfer syntax code for the import/export methods.
// PRECONDITIONS :
// POSTCONDITIONS :
// EXCEPTIONS :
// NOTES :
//<<===========================================================================
{
// set transfer syntax code
tsCodeM = tsCode;
// set the transfer syntax
transferSyntaxM = transferSyntax;
// set the underlying endian-ness for the transfer
if (tsCodeM & TS_LITTLE_ENDIAN)
{
setEndian(LITTLE_ENDIAN);
}
else
{
setEndian(BIG_ENDIAN);
}
}
_ByteArray::_ByteArray(std::size_t maxSize): wPos(0),rPos(0),_maxSize(0)
{
_maxSize=maxSize;
_bytes = new unsigned char[_maxSize];
Endian cpuEndian = getCPUEndian();
_sysEndian = cpuEndian;
setEndian(ENDIAN_BIG, ENDIAN_BIG);
}
BinaryInput::BinaryInput(
const uint8* data,
int64 dataLen,
G3DEndian dataEndian,
bool compressed,
bool copyMemory) :
m_filename("<memory>"),
m_bitPos(0),
m_bitString(0),
m_beginEndBits(0),
m_alreadyRead(0),
m_bufferLength(0),
m_pos(0) {
m_freeBuffer = copyMemory || compressed;
setEndian(dataEndian);
if (compressed) {
// Read the decompressed size from the first 4 bytes
m_length = G3D::readUInt32(data, m_swapBytes);
debugAssert(m_freeBuffer);
m_buffer = (uint8*)System::alignedMalloc(m_length, 16);
unsigned long L = m_length;
// Decompress with zlib
int64 result = uncompress(m_buffer, (unsigned long*)&L, data + 4, dataLen - 4);
m_length = L;
m_bufferLength = L;
debugAssert(result == Z_OK); (void)result;
} else {
m_length = dataLen;
m_bufferLength = m_length;
if (! copyMemory) {
debugAssert(!m_freeBuffer);
m_buffer = const_cast<uint8*>(data);
} else {
debugAssert(m_freeBuffer);
m_buffer = (uint8*)System::alignedMalloc(m_length, 16);
System::memcpy(m_buffer, data, dataLen);
}
}
}
DATA_TF_CLASS::DATA_TF_CLASS()
// DESCRIPTION : Constructor.
// PRECONDITIONS :
// POSTCONDITIONS :
// EXCEPTIONS :
// NOTES :
//<<===========================================================================
{
// constructor activities
storageModeM = SM_NO_STORAGE;
tsCodeM = TS_IMPLICIT_VR | TS_LITTLE_ENDIAN;
transferSyntaxM = IMPLICIT_VR_LITTLE_ENDIAN;
// set the underlying endian-ness for the transfer
setEndian(LITTLE_ENDIAN);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RawBinaryReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
/* Code to read the values goes between these statements */
/* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE BEGIN*/
setInputFile( reader->readValue( "InputFile", getInputFile() ) );
setScalarType( reader->readValue("ScalarType", getScalarType()) );
setDimensionality( reader->readValue("Dimensionality", getDimensionality()) );
setNumberOfComponents( reader->readValue("NumberOfComponents", getNumberOfComponents()) );
setEndian( reader->readValue("Endian", getEndian()) );
setDimensions( reader->readValue("Dimensions", getDimensions() ) );
setOrigin( reader->readValue("Origin", getOrigin() ) );
setResolution( reader->readValue("Resolution", getResolution() ) );
setOverRideOriginResolution( reader->readValue("OverRideOriginResolution", getOverRideOriginResolution()) );
setSkipHeaderBytes( reader->readValue("SkipHeaderBytes", getSkipHeaderBytes()) );
setOutputArrayName( reader->readValue( "OutputArrayName", getOutputArrayName() ) );
/* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE END*/
reader->closeFilterGroup();
}
BinaryOutput::BinaryOutput(
const std::string& filename,
G3DEndian fileEndian) {
m_pos = 0;
m_alreadyWritten = 0;
setEndian(fileEndian);
m_filename = filename;
m_buffer = NULL;
m_bufferLen = 0;
m_maxBufferLen = 0;
m_beginEndBits = 0;
m_bitString = 0;
m_bitPos = 0;
m_committed = false;
m_ok = true;
/** Verify ability to write to disk */
commit(false);
m_committed = false;
}
NETWORK_TF_CLASS::NETWORK_TF_CLASS()
// DESCRIPTION : Constructor.
// PRECONDITIONS :
// POSTCONDITIONS :
// EXCEPTIONS :
// NOTES :
//<<===========================================================================
{
// constructor activities
sessionIdM = 1;
pcIdM = 0;
isCommandContentM = false;
setEndian(LITTLE_ENDIAN);
dataTransferIndexM = 0;
dataTransferOffsetM = 0;
maxRxLengthM = 0;
maxTxLengthM = MAXIMUM_LENGTH_RECEIVED;
loggerM_ptr = NULL;
}
BinaryInput::BinaryInput(
const std::string& filename,
G3DEndian fileEndian,
bool compressed) :
m_filename(filename),
m_bitPos(0),
m_bitString(0),
m_beginEndBits(0),
m_alreadyRead(0),
m_length(0),
m_bufferLength(0),
m_buffer(NULL),
m_pos(0),
m_freeBuffer(true) {
setEndian(fileEndian);
// Update global file tracker
_internal::currentFilesUsed.insert(m_filename);
#if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */
std::string zipfile;
if (FileSystem::inZipfile(m_filename, zipfile)) {
// Load from zipfile
// zipRead(filename, v, s);
std::string internalFile = m_filename.substr(zipfile.length() + 1);
struct zip* z = zip_open(zipfile.c_str(), ZIP_CHECKCONS, NULL);
{
struct zip_stat info;
zip_stat_init( &info ); // TODO: Docs unclear if zip_stat_init is required.
zip_stat(z, internalFile.c_str(), ZIP_FL_NOCASE, &info);
m_bufferLength = m_length = info.size;
// sets machines up to use MMX, if they want
m_buffer = reinterpret_cast<uint8*>(System::alignedMalloc(m_length, 16));
struct zip_file* zf = zip_fopen( z, internalFile.c_str(), ZIP_FL_NOCASE );
{
int64 test = zip_fread( zf, m_buffer, m_length );
debugAssertM(test == m_length,
internalFile + " was corrupt because it unzipped to the wrong size.");
(void)test;
}
zip_fclose( zf );
}
zip_close( z );
if (compressed) {
decompress();
}
m_freeBuffer = true;
return;
}
#endif
// Figure out how big the file is and verify that it exists.
m_length = FileSystem::size(m_filename);
// Read the file into memory
FILE* file = fopen(m_filename.c_str(), "rb");
if (! file || (m_length == -1)) {
throw format("File not found: \"%s\"", m_filename.c_str());
return;
}
if (! compressed && (m_length > INITIAL_BUFFER_LENGTH)) {
// Read only a subset of the file so we don't consume
// all available memory.
m_bufferLength = INITIAL_BUFFER_LENGTH;
} else {
// Either the length is fine or the file is compressed
// and requires us to read the whole thing for zlib.
m_bufferLength = m_length;
}
debugAssert(m_freeBuffer);
m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16);
if (m_buffer == NULL) {
if (compressed) {
throw "Not enough memory to load compressed file. (1)";
}
// Try to allocate a small array; not much memory is available.
// Give up if we can't allocate even 1k.
while ((m_buffer == NULL) && (m_bufferLength > 1024)) {
m_bufferLength /= 2;
m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16);
}
}
debugAssert(m_buffer);
fread(m_buffer, m_bufferLength, sizeof(int8), file);
fclose(file);
file = NULL;
if (compressed) {
if (m_bufferLength != m_length) {
throw "Not enough memory to load compressed file. (2)";
}
decompress();
}
}
//=============================================================================
// setStereoVideoCapture()
//
// Given that the camera handle is a stereo camera, query the camera for
// stereo specific information about this camera and populate the
// PGRStereoCamera_t handle structure
//
// note: currently always allocated maximum framerate
dc1394error_t
setStereoVideoCapture( PGRStereoCamera_t* stereoCamera )
{
dc1394error_t err;
dc1394color_coding_t coding;
switch( stereoCamera->model )
{
case BUMBLEBEE:
dc1394video_mode_t videoMode;
dc1394framerate_t fps;
// note: both B&W and Bayer Bumblebees transmit in mono mode
if ( stereoCamera->nCols == 640 )
{
// lo res
printf("capture mode: DC1394_VIDEO_MODE_640x480_MONO16 ");
printf("capture mode: %d\n", DC1394_VIDEO_MODE_640x480_MONO16);
videoMode = DC1394_VIDEO_MODE_640x480_MONO16;
fps = DC1394_FRAMERATE_30;
}
else
{
printf("capture mode: DC1394_VIDEO_MODE_1024x768_MONO16 ");
printf("capture mode: %d\n", DC1394_VIDEO_MODE_1024x768_MONO16);
// assume hi res
videoMode = DC1394_VIDEO_MODE_1024x768_MONO16;
fps = DC1394_FRAMERATE_15;
}
// make the calls to set up the capture mode
dc1394_video_set_iso_speed( stereoCamera->camera, DC1394_ISO_SPEED_400 );
dc1394_video_set_mode( stereoCamera->camera, videoMode );
dc1394_video_set_framerate( stereoCamera->camera, fps );
err = dc1394_capture_setup( stereoCamera->camera, 8, DC1394_CAPTURE_FLAGS_DEFAULT );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't setup Bumblebee capture\n" );
return err;
}
break;
case BUMBLEBEE2:
// Bumblebee2 transmits stereo images in Format 7
// load the factory defaults - this is auto-everything
err = dc1394_memory_load( stereoCamera->camera, 0 );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't load default memory channel\n" );
return err;
}
// set 16-bit transmission to be PGR-default little endian mode
err = setEndian( stereoCamera->camera, false );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't set Bumblebee2 into little-endian mode\n" );
return err;
}
// color cameras transmit in "RAW16", mono cameras in "MONO16"
coding = DC1394_COLOR_CODING_MONO16;
if ( stereoCamera->bColor )
coding = DC1394_COLOR_CODING_RAW16;
dc1394_video_set_iso_speed( stereoCamera->camera, DC1394_ISO_SPEED_400 );
dc1394_video_set_mode( stereoCamera->camera, DC1394_VIDEO_MODE_FORMAT7_3 );
err = dc1394_format7_set_roi( stereoCamera->camera,
DC1394_VIDEO_MODE_FORMAT7_3,
coding,
// bytes per packet - sets frame rate
DC1394_USE_MAX_AVAIL,
0,
0,
stereoCamera->nCols,
stereoCamera->nRows );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't setup Bumblebee2 capture\n" );
return err;
}
err = dc1394_capture_setup( stereoCamera->camera, 8, DC1394_CAPTURE_FLAGS_DEFAULT );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't setup Bumblebee capture\n" );
return err;
}
break;
case BUMBLEBEEXB3:
// Bumblebee3 transmits stereo images in Format 7
// load the factory defaults - this is auto-everything
err = dc1394_memory_load( stereoCamera->camera, 0 );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't load default memory channel\n" );
return err;
}
if ( stereoCamera->nBytesPerPixel == 2 )
{
// run in 2 camera mode
// NOTE: this code will always only set up the wide-baseline pair
// To change to the inner baseline pair you need to set the PAN
// register to 1.
// PAN = 0 is the wide baseline pair which is set by default.
// To change to all 3 images being transmitted you need to change
// modes to "coding = DC1394_COLOR_CODING_RGB8;"
//
// set 16-bit transmission to be PGR-default little endian mode
err = setEndian( stereoCamera->camera, false );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't set Bumblebee2 into little-endian mode\n" );
return err;
}
// color cameras transmit in "RAW16", mono cameras in "MONO16"
coding = DC1394_COLOR_CODING_MONO16;
if ( stereoCamera->bColor )
coding = DC1394_COLOR_CODING_RAW16;
}
else
{
// 3 camera mode transmits in RGB8
coding = DC1394_COLOR_CODING_RGB8;
}
// assume the XB is plugged into a 1394B network
// XB3 can work with a 1394A bus but code changes will be required
dc1394_video_set_operation_mode( stereoCamera->camera, DC1394_OPERATION_MODE_1394B );
dc1394_video_set_iso_speed( stereoCamera->camera, DC1394_ISO_SPEED_800 );
dc1394_video_set_mode( stereoCamera->camera, DC1394_VIDEO_MODE_FORMAT7_3 );
err = dc1394_format7_set_roi( stereoCamera->camera,
DC1394_VIDEO_MODE_FORMAT7_3,
coding,
// bytes per packet - sets frame rate
DC1394_USE_MAX_AVAIL,
0,
0,
stereoCamera->nCols,
stereoCamera->nRows );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't setup Bumblebee XB3 capture\n" );
return err;
}
err = dc1394_capture_setup( stereoCamera->camera, 4, DC1394_CAPTURE_FLAGS_DEFAULT );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Can't setup Bumblebee capture\n" );
return err;
}
break;
default:
fprintf( stderr,
"setStereoVideoCapture() - \n"
"\tThis camera is not a supported stereo camera!\n" );
return DC1394_FAILURE;
}
// get the bayer tile info so we will know how to color process
// this mode
err = getBayerTile( stereoCamera->camera,
&stereoCamera->bayerTile );
if ( err != DC1394_SUCCESS )
{
fprintf( stderr, "Could not query the Bayer Tile Register!\n" );
return err;
}
return DC1394_SUCCESS;
}
BinaryInput::BinaryInput(
const std::string& filename,
G3DEndian fileEndian,
bool compressed) :
m_filename(filename),
m_bitPos(0),
m_bitString(0),
m_beginEndBits(0),
m_alreadyRead(0),
m_length(0),
m_bufferLength(0),
m_buffer(NULL),
m_pos(0),
m_freeBuffer(true) {
setEndian(fileEndian);
// Update global file tracker
_internal::currentFilesUsed.insert(m_filename);
if (! fileExists(m_filename, false)) {
std::string zipfile;
std::string internalfile;
if (zipfileExists(m_filename, zipfile, internalfile)) {
// Load from zipfile
void* v;
size_t s;
zipRead(filename, v, s);
m_buffer = reinterpret_cast<uint8*>(v);
m_bufferLength = m_length = s;
if (compressed) {
decompress();
}
m_freeBuffer = true;
} else {
Log::common()->printf("Warning: File not found: %s\n", m_filename.c_str());
}
return;
}
// Figure out how big the file is and verify that it exists.
m_length = fileLength(m_filename);
// Read the file into memory
FILE* file = fopen(m_filename.c_str(), "rb");
if (! file || (m_length == -1)) {
throw format("File not found: \"%s\"", m_filename.c_str());
return;
}
if (! compressed && (m_length > INITIAL_BUFFER_LENGTH)) {
// Read only a subset of the file so we don't consume
// all available memory.
m_bufferLength = INITIAL_BUFFER_LENGTH;
} else {
// Either the length is fine or the file is compressed
// and requires us to read the whole thing for zlib.
m_bufferLength = m_length;
}
debugAssert(m_freeBuffer);
m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16);
if (m_buffer == NULL) {
if (compressed) {
throw "Not enough memory to load compressed file. (1)";
}
// Try to allocate a small array; not much memory is available.
// Give up if we can't allocate even 1k.
while ((m_buffer == NULL) && (m_bufferLength > 1024)) {
m_bufferLength /= 2;
m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16);
}
}
debugAssert(m_buffer);
fread(m_buffer, m_bufferLength, sizeof(int8), file);
fclose(file);
file = NULL;
if (compressed) {
if (m_bufferLength != m_length) {
throw "Not enough memory to load compressed file. (2)";
}
decompress();
}
}
DataTypesWidget::DataTypesWidget(QWidget *parent): QWidget(parent), ui(new Ui::DataTypesWidget)
{
ui->setupUi(this);
this->_datatypesmodel = new DataTypesModel(this);
this->_datatypesdelegate = new DataTypesDelegate(this);
this->_datatypesmenu = new DataTypesMenu(this);
connect(this->_datatypesmenu, SIGNAL(endianChanged(QSysInfo::Endian)),this->_datatypesmodel, SLOT(setEndian(QSysInfo::Endian)));
connect(this->_datatypesmenu, SIGNAL(baseChanged(int)), this->_datatypesmodel, SLOT(setBase(int)));
this->_datatypesmenu->setBase(16); /* Hex By Default */
this->_datatypesmenu->setEndian(QSysInfo::ByteOrder);
ui->dataTypesTable->setModel(this->_datatypesmodel);
ui->dataTypesTable->setItemDelegate(this->_datatypesdelegate);
}
