int IGTLinkImageMessage::Pack()
{
PackBody();
igtl::MessageBase::m_IsBodyUnpacked = 0;
// pack header
igtl_header* h = (igtl_header*) igtl::MessageBase::m_Header;
//igtl_uint64 crc = crc64(0, 0, 0LL); // initial crc //SKIPPING CRC
h->version = IGTL_HEADER_VERSION;
igtl_uint64 ts = igtl::MessageBase::m_TimeStampSec & 0xFFFFFFFF;
ts = (ts << 32) | (igtl::MessageBase::m_TimeStampSecFraction & 0xFFFFFFFF);
h->timestamp = ts;
h->body_size = GetBodyPackSize();
//h->crc = crc64((unsigned char*)igtl::MessageBase::m_Body, GetBodyPackSize(), crc); //SKIPPING CRC
h->crc = 0;
strncpy(h->name, igtl::MessageBase::m_DefaultBodyType.c_str(), 12);
// TODO: this does not allow creating pack with MessageBase class...
strncpy(h->device_name, igtl::MessageBase::m_DeviceName.c_str(), 20);
igtl_header_convert_byte_order(h);
igtl::MessageBase::m_IsHeaderUnpacked = 0;
return 1;
}
int main( int argc, char * argv [] )
{
struct transform_message message;
int r;
/* Set dummy transform */
message.transform[0] = -0.954892f;
message.transform[1] = 0.196632f;
message.transform[2] = -0.222525f;
message.transform[3] = -0.196632f;
message.transform[4] = 0.142857f;
message.transform[5] = 0.970014f;
message.transform[6] = 0.222525f;
message.transform[7] = 0.970014f;
message.transform[8] = -0.0977491f;
message.transform[9] = 46.0531f;
message.transform[10] = 19.4709f;
message.transform[11] = 46.0531f;
igtl_transform_convert_byte_order(message.transform);
/* Set header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "TRANSFORM", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567890;
message.header.body_size = IGTL_TRANSFORM_SIZE;
message.header.crc = igtl_transform_get_crc(message.transform);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for testing */
/*
FILE *fp;
fp = fopen("transform.bin", "w");
fwrite(&(message.header), IGTL_HEADER_SIZE+IGTL_TRANSFORM_SIZE, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_transform_message,
IGTL_HEADER_SIZE+IGTL_TRANSFORM_SIZE);
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print message as HEX values in STDERR for debug */
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", IGTL_HEADER_SIZE+IGTL_TRANSFORM_SIZE);
igtl_message_dump_hex(stdout, (const void*)&message, IGTL_HEADER_SIZE+IGTL_TRANSFORM_SIZE);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
igtl_header header;
// Test structure size
if (sizeof(header) != IGTL_HEADER_SIZE)
{
fprintf(stdout, "Invalid size of header structure.\n");
return EXIT_FAILURE;
}
// Test binary
header.version = 1;
strncpy( header.name, "TYPENAME", 12 );
strncpy( header.device_name, "DeviceName", 20 );
header.timestamp = 1234567890;
header.body_size = 31415926534;
header.crc = 1343143;
igtl_header_convert_byte_order( &header );
if (memcmp((const void*)&header, (const void*)barray, IGTL_HEADER_SIZE) == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print message as HEX values in STDERR for debug */
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", IGTL_HEADER_SIZE);
igtl_message_dump_hex(stdout, (const void*)&header, IGTL_HEADER_SIZE);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct sensor_message message;
igtl_unit_data unit_data;
/*igtl_uint64 crc;*/
unsigned int value_size;
int r;
int s;
// Test structure size
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_SENSOR_HEADER_SIZE+sizeof(igtl_float64)*6)
{
fprintf(stdout, "Invalid size of sensor message structure.\n");
return EXIT_FAILURE;
}
/* Create unit (m/s^2) */
igtl_unit_init(&unit_data);
unit_data.prefix = IGTL_UNIT_PREFIX_NONE;
unit_data.unit[0] = IGTL_UNIT_SI_BASE_METER;
unit_data.exp[0] = (igtl_int8) 1;
unit_data.unit[1] = IGTL_UNIT_SI_BASE_SECOND;
unit_data.exp[1] = (igtl_int8) -2;
/* Set dummy sensor header and values */
message.sensor.larray = 6;
message.sensor.status = 0;
message.sensor.unit = igtl_unit_pack(&(unit_data));
message.value[0] = 123456.78;
message.value[1] = 12345.678;
message.value[2] = 1234.5678;
message.value[3] = 123.45678;
message.value[4] = 12.345678;
message.value[5] = 1.2345678;
value_size = igtl_sensor_get_data_size(&(message.sensor));
igtl_sensor_convert_byte_order(&(message.sensor), message.value);
/* Set header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "SENSOR", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567890;
message.header.body_size = IGTL_SENSOR_HEADER_SIZE + value_size;
message.header.crc = igtl_sensor_get_crc(&(message.sensor), message.value);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for testing */
/*
FILE *fp;
fp = fopen("sensor.bin", "w");
fwrite(&(message.header), IGTL_HEADER_SIZE+IGTL_SENSOR_HEADER_SIZE + value_size, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_sensor_message,
IGTL_HEADER_SIZE+IGTL_SENSOR_HEADER_SIZE+value_size);
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_SENSOR_HEADER_SIZE+value_size;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct string_message message;
/*igtl_uint64 crc;*/
int r;
int s;
// Test structure size
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_STRING_HEADER_SIZE+IGTL_STRING_TEST_STRING_LEN)
{
fprintf(stdout, "Invalid size of image message structure.\n");
return EXIT_FAILURE;
}
/* Set dummy string header and values */
message.string_header.encoding = 3;
message.string_header.length = IGTL_STRING_TEST_STRING_LEN;
strncpy((char*)message.string, IGTL_STRING_TEST_STRING, IGTL_STRING_TEST_STRING_LEN);
igtl_string_convert_byte_order(&(message.string_header));
/* Set header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "STRING", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567892;
message.header.body_size = IGTL_STRING_HEADER_SIZE + IGTL_STRING_TEST_STRING_LEN;
message.header.crc = igtl_string_get_crc(&(message.string_header), (void*) message.string);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for testing */
/*
FILE *fp;
fp = fopen("string.bin", "w");
fwrite(&(message.header), IGTL_HEADER_SIZE+IGTL_STRING_HEADER_SIZE + IGTL_STRING_TEST_STRING_LEN, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_string_message,
IGTL_HEADER_SIZE+IGTL_STRING_HEADER_SIZE+IGTL_STRING_TEST_STRING_LEN);
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_STRING_HEADER_SIZE+IGTL_STRING_TEST_STRING_LEN;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct trajectory_message message;
int r;
int s;
// Test structure size
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_TRAJECTORY_ELEMENT_SIZE*TEST_TRAJECTORY_NUM)
{
fprintf(stdout, "Invalid size of trajectory message structure.\n");
return EXIT_FAILURE;
}
/* Trajectory data 0 */
strncpy((char*)&(message.tlist[0].name), "TRAJECTORY_DESCRIPTION_0", 64);
strncpy((char*)&(message.tlist[0].group_name), "TRAJECTORY", 32);
message.tlist[0].type = IGTL_TRAJECTORY_TYPE_ENTRY_TARGET;
message.tlist[0].reserved = 0;
message.tlist[0].rgba[0] = 255;
message.tlist[0].rgba[1] = 0;
message.tlist[0].rgba[2] = 0;
message.tlist[0].rgba[3] = 255;
message.tlist[0].entry_pos[0] = 10.0;
message.tlist[0].entry_pos[1] = 15.0;
message.tlist[0].entry_pos[2] = 20.0;
message.tlist[0].target_pos[0] = 25.0;
message.tlist[0].target_pos[1] = 30.0;
message.tlist[0].target_pos[2] = 35.0;
message.tlist[0].radius = 5.0;
strncpy((char*)&(message.tlist[0].owner_name), "IMAGE_0", 20);
/* Trajectory data 1 */
strncpy((char*)&(message.tlist[1].name), "TRAJECTORY_DESCRIPTION_1", 64);
strncpy((char*)&(message.tlist[1].group_name), "TRAJECTORY", 32);
message.tlist[1].type = IGTL_TRAJECTORY_TYPE_ENTRY_TARGET;
message.tlist[1].reserved = 0;
message.tlist[1].rgba[0] = 0;
message.tlist[1].rgba[1] = 255;
message.tlist[1].rgba[2] = 0;
message.tlist[1].rgba[3] = 255;
message.tlist[1].entry_pos[0] = 40.0;
message.tlist[1].entry_pos[1] = 45.0;
message.tlist[1].entry_pos[2] = 50.0;
message.tlist[1].target_pos[0] = 55.0;
message.tlist[1].target_pos[1] = 60.0;
message.tlist[1].target_pos[2] = 65.0;
message.tlist[1].radius = 2.5;
strncpy((char*)&(message.tlist[1].owner_name), "IMAGE_0", 20);
/* Trajectory data 1 */
strncpy((char*)&(message.tlist[2].name), "TRAJECTORY_DESCRIPTION_2", 64);
strncpy((char*)&(message.tlist[2].group_name), "TRAJECTORY", 32);
message.tlist[2].type = IGTL_TRAJECTORY_TYPE_ENTRY_TARGET;
message.tlist[2].reserved = 0;
message.tlist[2].rgba[0] = 0;
message.tlist[2].rgba[1] = 0;
message.tlist[2].rgba[2] = 255;
message.tlist[2].rgba[3] = 255;
message.tlist[2].entry_pos[0] = 70.0;
message.tlist[2].entry_pos[1] = 75.0;
message.tlist[2].entry_pos[2] = 80.0;
message.tlist[2].target_pos[0] = 85.0;
message.tlist[2].target_pos[1] = 90.0;
message.tlist[2].target_pos[2] = 95.0;
message.tlist[2].radius = 0.0;
strncpy((char*)&(message.tlist[2].owner_name), "IMAGE_0", 20);
/* Swap byte order if necessary */
igtl_trajectory_convert_byte_order(message.tlist, TEST_TRAJECTORY_NUM);
/* Create OpenIGTLink header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "TRAJ", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567890;
message.header.body_size = IGTL_TRAJECTORY_ELEMENT_SIZE*TEST_TRAJECTORY_NUM;
message.header.crc = igtl_trajectory_get_crc(message.tlist, TEST_TRAJECTORY_NUM);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for debugging */
/*
FILE *fp;
fp = fopen("trajectory.bin", "w");
fwrite(&(message), IGTL_HEADER_SIZE+IGTL_TRAJECTORY_ELEMENT_SIZE*TEST_TRAJECTORY_NUM, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_trajectory_message,
(size_t)(IGTL_HEADER_SIZE+IGTL_TRAJECTORY_ELEMENT_SIZE*TEST_TRAJECTORY_NUM));
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_TRAJECTORY_ELEMENT_SIZE*TEST_TRAJECTORY_NUM;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
//igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct image_message message;
int r;
igtl_uint64 image_size;
int s;
igtl_float32 spacing[] = {1.0f, 1.0f, 1.0f};
igtl_float32 origin[] = {46.0531f, 19.4709f, 46.0531f};
igtl_float32 norm_i[] = {-0.954892f, 0.196632f, -0.222525f};
igtl_float32 norm_j[] = {-0.196632f, 0.142857f, 0.970014f};
igtl_float32 norm_k[] = {0.222525f, 0.970014f, -0.0977491f};
/* Test structure size */
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_IMAGE_HEADER_SIZE+TEST_IMAGE_MESSAGE_SIZE)
{
fprintf(stdout, "Invalid size of image message structure.\n");
return EXIT_FAILURE;
}
/* Set data */
message.iheader.version = 1;
message.iheader.num_components = 1; /* Scalar */
message.iheader.scalar_type = 3; /* uint8 */
message.iheader.endian = 2; /* Little endian */
message.iheader.coord = 1; /* RAS */
message.iheader.size[0] = 50;
message.iheader.size[1] = 50;
message.iheader.size[2] = 1;
/* Dimensions */
message.iheader.subvol_offset[0] = 0;
message.iheader.subvol_offset[1] = 0;
message.iheader.subvol_offset[2] = 0;
message.iheader.subvol_size[0] = 50;
message.iheader.subvol_size[1] = 50;
message.iheader.subvol_size[2] = 1;
igtl_image_set_matrix(spacing, origin, norm_i, norm_j, norm_k, &(message.iheader));
/* Copy image data */
memcpy((void*)message.image, (void*)test_image, TEST_IMAGE_MESSAGE_SIZE);
/* Get image data size -- note that this should be done before byte order swapping. */
image_size = igtl_image_get_data_size(&(message.iheader));
/* Swap byte order if necessary */
igtl_image_convert_byte_order(&(message.iheader));
/* Create OpenIGTLink header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "IMAGE", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567892;
message.header.body_size = IGTL_IMAGE_HEADER_SIZE + image_size;
message.header.crc = igtl_image_get_crc(&(message.iheader), message.image);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for debugging */
/*
FILE *fp;
fp = fopen("image.bin", "w");
fwrite(&(message), IGTL_HEADER_SIZE+IGTL_IMAGE_HEADER_SIZE+image_size, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_image_message,
(size_t)(IGTL_HEADER_SIZE+IGTL_IMAGE_HEADER_SIZE+image_size));
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_IMAGE_HEADER_SIZE+ (int)image_size;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct imgmeta_message message;
int r;
int s;
/* Test structure size */
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_IMGMETA_ELEMENT_SIZE*TEST_IMGMETA_NUM)
{
fprintf(stdout, "Invalid size of imgmeta message structure.\n");
return EXIT_FAILURE;
}
/* Image meta data 0 */
strncpy((char*)&(message.metalist[0].name), "IMAGE_DESCRIPTION_0", 64);
strncpy((char*)&(message.metalist[0].device_name), "IMAGE_0", 20);
strncpy((char*)&(message.metalist[0].modality), "CT", 32);
strncpy((char*)&(message.metalist[0].patient_name), "PATIENT_0", 64);
strncpy((char*)&(message.metalist[0].patient_id), "PATIENT_ID_0", 64);
message.metalist[0].timestamp = 1234567890;
message.metalist[0].size[0] = 512;
message.metalist[0].size[1] = 512;
message.metalist[0].size[2] = 64;
message.metalist[0].scalar_type = IGTL_IMAGE_STYPE_TYPE_UINT16;
message.metalist[0].reserved = 0;
/* Image meta data 1 */
strncpy((char*)&(message.metalist[1].name), "IMAGE_DESCRIPTION_1", 64);
strncpy((char*)&(message.metalist[1].device_name), "IMAGE_1", 20);
strncpy((char*)&(message.metalist[1].modality), "MRI", 32);
strncpy((char*)&(message.metalist[1].patient_name), "PATIENT_1", 64);
strncpy((char*)&(message.metalist[1].patient_id), "PATIENT_ID_1", 64);
message.metalist[1].timestamp = 1234567891;
message.metalist[1].size[0] = 256;
message.metalist[1].size[1] = 128;
message.metalist[1].size[2] = 32;
message.metalist[1].scalar_type = IGTL_IMAGE_STYPE_TYPE_UINT16;
message.metalist[1].reserved = 0;
/* Image meta data 2 */
strncpy((char*)&(message.metalist[2].name), "IMAGE_DESCRIPTION_2", 64);
strncpy((char*)&(message.metalist[2].device_name), "IMAGE_2", 20);
strncpy((char*)&(message.metalist[2].modality), "PET", 32);
strncpy((char*)&(message.metalist[2].patient_name), "PATIENT_2", 64);
strncpy((char*)&(message.metalist[2].patient_id), "PATIENT_ID_2", 64);
message.metalist[2].timestamp = 1234567892;
message.metalist[2].size[0] = 256;
message.metalist[2].size[1] = 256;
message.metalist[2].size[2] = 32;
message.metalist[2].scalar_type = IGTL_IMAGE_STYPE_TYPE_UINT16;
message.metalist[2].reserved = 0;
/* Swap byte order if necessary */
igtl_imgmeta_convert_byte_order(message.metalist, TEST_IMGMETA_NUM);
/* Create OpenIGTLink header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "IMGMETA", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567890;
message.header.body_size = IGTL_IMGMETA_ELEMENT_SIZE*TEST_IMGMETA_NUM;
message.header.crc = igtl_imgmeta_get_crc(message.metalist, TEST_IMGMETA_NUM);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for debugging */
/*
FILE *fp;
fp = fopen("imgmeta.bin", "w");
fwrite(&(message), IGTL_HEADER_SIZE+IGTL_IMGMETA_ELEMENT_SIZE*TEST_IMGMETA_NUM, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_imgmeta_message,
(size_t)(IGTL_HEADER_SIZE+IGTL_IMGMETA_ELEMENT_SIZE*TEST_IMGMETA_NUM));
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_IMGMETA_ELEMENT_SIZE*TEST_IMGMETA_NUM;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct colortable_message message;
igtl_uint64 table_size;
int r;
int s;
int i;
/* Test structure size */
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_COLORTABLE_HEADER_SIZE+TEST_COLORTABLE_SIZE)
{
fprintf(stdout, "Invalid size of colortable message structure.\n");
return EXIT_FAILURE;
}
/* Set COLORTABLE message */
message.cheader.indexType = IGTL_COLORTABLE_INDEX_UINT8;
message.cheader.mapType = IGTL_COLORTABLE_MAP_UINT8;
for (i = 0; i < 256; i ++)
{
message.table[i] = i;
}
/* Get image data size -- note that this should be done before byte order swapping. */
table_size = igtl_colortable_get_table_size(&(message.cheader));
/* Swap byte order if necessary */
igtl_colortable_convert_byte_order(&(message.cheader), (void*)&(message.table));
/* Create OpenIGTLink header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "COLORTABLE", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567890;
message.header.body_size = IGTL_COLORTABLE_HEADER_SIZE + table_size;
message.header.crc = igtl_colortable_get_crc(&(message.cheader), (void*)message.table);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for debugging */
/*
FILE *fp;
fp = fopen("colortable.bin", "w");
fwrite(&(message), IGTL_HEADER_SIZE+IGTL_COLORTABLE_HEADER_SIZE+TEST_COLORTABLE_SIZE, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_colortable_message,
(size_t)(IGTL_HEADER_SIZE+IGTL_COLORTABLE_HEADER_SIZE));
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_COLORTABLE_HEADER_SIZE+(int)table_size;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct point_message message;
int r;
int s;
/* Test structure size */
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_POINT_ELEMENT_SIZE*TEST_POINT_NUM)
{
fprintf(stdout, "Invalid size of point message structure.\n");
return EXIT_FAILURE;
}
/* Point data 0 */
strncpy((char*)&(message.pointlist[0].name), "POINT_DESCRIPTION_0", 64);
strncpy((char*)&(message.pointlist[0].group_name), "Landmark", 32);
message.pointlist[0].rgba[0] = 255;
message.pointlist[0].rgba[1] = 0;
message.pointlist[0].rgba[2] = 0;
message.pointlist[0].rgba[3] = 255;
message.pointlist[0].position[0] = 10.0;
message.pointlist[0].position[1] = 15.0;
message.pointlist[0].position[2] = 20.0;
message.pointlist[0].radius = 5.0;
strncpy((char*)&(message.pointlist[0].owner), "IMAGE_0", 20);
/* Point data 1 */
strncpy((char*)&(message.pointlist[1].name), "POINT_DESCRIPTION_1", 64);
strncpy((char*)&(message.pointlist[1].group_name), "Landmark", 32);
message.pointlist[1].rgba[0] = 0;
message.pointlist[1].rgba[1] = 255;
message.pointlist[1].rgba[2] = 0;
message.pointlist[1].rgba[3] = 255;
message.pointlist[1].position[0] = 25.0;
message.pointlist[1].position[1] = 30.0;
message.pointlist[1].position[2] = 35.0;
message.pointlist[1].radius = 3.0;
strncpy((char*)&(message.pointlist[1].owner), "IMAGE_0", 20);
/* Point data 2 */
strncpy((char*)&(message.pointlist[2].name), "POINT_DESCRIPTION_2", 64);
strncpy((char*)&(message.pointlist[2].group_name), "Landmark", 32);
message.pointlist[2].rgba[0] = 0;
message.pointlist[2].rgba[1] = 0;
message.pointlist[2].rgba[2] = 255;
message.pointlist[2].rgba[3] = 255;
message.pointlist[2].position[0] = 40.0;
message.pointlist[2].position[1] = 45.0;
message.pointlist[2].position[2] = 50.0;
message.pointlist[2].radius = 1.0;
strncpy((char*)&(message.pointlist[2].owner), "IMAGE_0", 20);
/* Swap byte order if necessary */
igtl_point_convert_byte_order(message.pointlist, TEST_POINT_NUM);
/* Create OpenIGTLink header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "POINT", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567890;
message.header.body_size = IGTL_POINT_ELEMENT_SIZE*TEST_POINT_NUM;
message.header.crc = igtl_point_get_crc(message.pointlist, TEST_POINT_NUM);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for debugging */
/*
FILE *fp;
fp = fopen("point.bin", "w");
fwrite(&(message), IGTL_HEADER_SIZE+IGTL_POINT_ELEMENT_SIZE*TEST_POINT_NUM, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_point_message,
(size_t)(IGTL_HEADER_SIZE+IGTL_POINT_ELEMENT_SIZE*TEST_POINT_NUM));
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_POINT_ELEMENT_SIZE*TEST_POINT_NUM;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
/* Message structures and byte array */
igtl_header header;
void* bind_header;
child_message_body child_body;
igtl_bind_info bind_info;
size_t bind_size;
size_t child_body_size;
int rh; /* Comparison result for header */
int rb; /* Comparison result for BIND header section*/
int rc; /* Comparison result for child body section */
int s;
igtl_bind_init_info(&bind_info);
/* Generate transform message */
generate_transform_body(&(child_body.transform));
/* Generate image message */
generate_image_body(&(child_body.image));
/* Generate sensor message */
generate_sensor_body(&(child_body.sensor));
/* Set up BIND info structure */
if (igtl_bind_alloc_info(&bind_info, 3) == 0)
{
return EXIT_FAILURE;
}
strncpy(bind_info.child_info_array[0].type, "TRANSFORM", IGTL_HEADER_TYPE_SIZE);
strncpy(bind_info.child_info_array[0].name, "ChildTrans", IGTL_HEADER_NAME_SIZE);
bind_info.child_info_array[0].size = sizeof(transform_message_body);
bind_info.child_info_array[0].ptr = (void*)&child_body.transform;
strncpy(bind_info.child_info_array[1].type, "IMAGE", IGTL_HEADER_TYPE_SIZE);
strncpy(bind_info.child_info_array[1].name, "ChildImage", IGTL_HEADER_NAME_SIZE);
bind_info.child_info_array[1].size = sizeof(image_message_body);
bind_info.child_info_array[1].ptr = (void*)&child_body.image;
strncpy(bind_info.child_info_array[2].type, "SENSOR", IGTL_HEADER_TYPE_SIZE);
strncpy(bind_info.child_info_array[2].name, "ChildSensor", IGTL_HEADER_NAME_SIZE);
bind_info.child_info_array[2].size = sizeof(sensor_message_body);
bind_info.child_info_array[2].ptr = (void*)&child_body.sensor;
bind_size = (size_t)igtl_bind_get_size(&bind_info, IGTL_TYPE_PREFIX_NONE);
bind_header = malloc(bind_size);
if (bind_header == NULL)
{
igtl_bind_free_info(&bind_info);
return EXIT_FAILURE;
}
igtl_bind_pack(&bind_info, bind_header, IGTL_TYPE_PREFIX_NONE);
/* Calculate the sum of child body size and paddings (0 in this test program) */
child_body_size = (size_t)
(bind_info.child_info_array[0].size +
bind_info.child_info_array[1].size +
bind_info.child_info_array[2].size);
/* Set header */
header.version = 1;
strncpy( (char*)&(header.name), "BIND", 12 );
strncpy( (char*)&(header.device_name), "DeviceName", 20 );
header.timestamp = 1234567890;
header.body_size = bind_size + sizeof(child_message_body);
header.crc = igtl_bind_get_crc(&bind_info, IGTL_TYPE_PREFIX_NONE, bind_header);
igtl_header_convert_byte_order( &(header) );
/* Dumping data -- for testing */
/*
FILE *fp;
fp = fopen("bind.bin", "w");
fwrite(&(header), IGTL_HEADER_SIZE, 1, fp);
fwrite(bind_header, bind_size, 1, fp);
fwrite(&(child_body), child_body_size, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
rh = memcmp((const void*)&header, (const void*)test_bind_message_header, IGTL_HEADER_SIZE);
rb = memcmp((const void*)bind_header, (const void*)test_bind_message_bind_header, bind_size);
rc = memcmp((const void*)&child_body, (const void*)test_bind_message_bind_body, child_body_size);
igtl_bind_free_info(&bind_info);
free(bind_header);
if (rh == 0 && rb == 0 && rc == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+bind_size+child_body_size;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&header, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
/*** Message structures and byte array ***/
igtl_header header;
void * body;
igtl_ndarray_info info;
size_t body_size;
igtl_uint16 size[3];
int i, j, k;
igtl_float64 * array;
int rh; /* Comparison result for header */
int rb; /* Comparison result for body */
int s;
/*** Generate test data ***/
igtl_ndarray_init_info(&info);
info.type = IGTL_NDARRAY_STYPE_TYPE_FLOAT64;
/* Array size is 5x4x3 */
info.dim = 3;
size[0] = 5;
size[1] = 4;
size[2] = 3;
if (igtl_ndarray_alloc_info(&info, size) == 0)
{
return EXIT_FAILURE;
}
/* Generate dummy array */
array = (igtl_float64 *) info.array;
for (i = 0; i < 5; i ++)
{
for (j = 0; j < 4; j ++)
{
for (k = 0; k < 3; k ++)
{
array[i*(4*3) + j*3 + k] = (igtl_float64) (i*(4*3) + j*3 + k);
}
}
}
/** Allocate memory for pack **/
body_size = (size_t)igtl_ndarray_get_size(&info, IGTL_TYPE_PREFIX_NONE);
body = malloc(body_size);
if (body == NULL)
{
igtl_ndarray_free_info(&info);
return EXIT_FAILURE;
}
igtl_ndarray_pack(&info, body, IGTL_TYPE_PREFIX_NONE);
/*** Set OpenIGTLink header ***/
header.version = 1;
strncpy( (char*)&(header.name), "NDARRAY", 12 );
strncpy( (char*)&(header.device_name), "DeviceName", 20 );
header.timestamp = 1234567892;
header.body_size = body_size;
header.crc = igtl_ndarray_get_crc(&info, IGTL_TYPE_PREFIX_NONE, body);
igtl_header_convert_byte_order( &(header) );
/* Dumping data -- for testing */
/*
FILE *fp;
fp = fopen("ndarray.bin", "w");
fwrite(&(header), IGTL_HEADER_SIZE, 1, fp);
fwrite(body, body_size, 1, fp);
fclose(fp);
*/
rh = memcmp((const void*)&header, (const void*)test_ndarray_message_header, IGTL_HEADER_SIZE);
rb = memcmp((const void*)body, (const void*)test_ndarray_message_body, body_size);
igtl_ndarray_free_info(&info);
free(body);
if (rh == 0 && rb == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE + body_size;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&header, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
struct lbmeta_message message;
int r;
int s;
// Test structure size
if (sizeof(message) != IGTL_HEADER_SIZE+IGTL_LBMETA_ELEMENT_SIZE*TEST_LBMETA_NUM)
{
fprintf(stdout, "Invalid size of lbmeta message structure.\n");
return EXIT_FAILURE;
}
/* Label meta data 0 */
strncpy((char*)&(message.metalist[0].name), "LABEL_DESCRIPTION_0", 64);
strncpy((char*)&(message.metalist[0].device_name), "LABEL_0", 20);
message.metalist[0].label = 1;
message.metalist[0].reserved = 0;
message.metalist[0].rgba[0] = 255;
message.metalist[0].rgba[1] = 0;
message.metalist[0].rgba[2] = 0;
message.metalist[0].rgba[3] = 255;
message.metalist[0].size[0] = 256;
message.metalist[0].size[1] = 128;
message.metalist[0].size[2] = 32;
strncpy((char*)&(message.metalist[0].owner), "IMAGE_0", 20);
/* Label meta data 1 */
strncpy((char*)&(message.metalist[1].name), "LABEL_DESCRIPTION_1", 64);
strncpy((char*)&(message.metalist[1].device_name), "LABEL_1", 20);
message.metalist[1].label = 2;
message.metalist[1].reserved = 0;
message.metalist[1].rgba[0] = 0;
message.metalist[1].rgba[1] = 255;
message.metalist[1].rgba[2] = 0;
message.metalist[1].rgba[3] = 255;
message.metalist[1].size[0] = 256;
message.metalist[1].size[1] = 128;
message.metalist[1].size[2] = 32;
strncpy((char*)&(message.metalist[1].owner), "IMAGE_0", 20);
/* Label meta data 2 */
strncpy((char*)&(message.metalist[2].name), "LABEL_DESCRIPTION_2", 64);
strncpy((char*)&(message.metalist[2].device_name), "LABEL_2", 20);
message.metalist[2].label = 3;
message.metalist[2].reserved = 0;
message.metalist[2].rgba[0] = 0;
message.metalist[2].rgba[1] = 0;
message.metalist[2].rgba[2] = 255;
message.metalist[2].rgba[3] = 255;
message.metalist[2].size[0] = 256;
message.metalist[2].size[1] = 128;
message.metalist[2].size[2] = 32;
strncpy((char*)&(message.metalist[2].owner), "IMAGE_0", 20);
/* Swap byte order if necessary */
igtl_lbmeta_convert_byte_order(message.metalist, TEST_LBMETA_NUM);
/* Create OpenIGTLink header */
message.header.version = 1;
strncpy( (char*)&(message.header.name), "LBMETA", 12 );
strncpy( (char*)&(message.header.device_name), "DeviceName", 20 );
message.header.timestamp = 1234567892;
message.header.body_size = IGTL_LBMETA_ELEMENT_SIZE*TEST_LBMETA_NUM;
message.header.crc = igtl_lbmeta_get_crc(message.metalist, TEST_LBMETA_NUM);
igtl_header_convert_byte_order( &(message.header) );
/* Dumping data -- for debugging */
/*
FILE *fp;
fp = fopen("lbmeta.bin", "w");
fwrite(&(message), IGTL_HEADER_SIZE+IGTL_LBMETA_ELEMENT_SIZE*TEST_LBMETA_NUM, 1, fp);
fclose(fp);
*/
/* Compare the serialized byte array with the gold standard */
r = memcmp((const void*)&message, (const void*)test_lbmeta_message,
(size_t)(IGTL_HEADER_SIZE+IGTL_LBMETA_ELEMENT_SIZE*TEST_LBMETA_NUM));
if (r == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE+IGTL_LBMETA_ELEMENT_SIZE*TEST_LBMETA_NUM;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&message, s);
return EXIT_FAILURE;
}
}
int main( int argc, char * argv [] )
{
/*** Message structures and byte array ***/
igtl_header header;
void * body;
igtl_polydata_info info;
int rh; /* Comparison result for header */
int rb; /* Comparison result for body */
unsigned int i;
int s;
igtl_float32 * ptr_f;
igtl_uint32 * ptr_i;
igtl_uint64 body_size;
static igtl_float32 points[8][3]={{0,0,0}, {1,0,0}, {1,1,0}, {0,1,0},
{0,0,1}, {1,0,1}, {1,1,1}, {0,1,1}};
static igtl_uint32 poly[6][4]={{0,1,2,3}, {4,5,6,7}, {0,1,5,4},
{1,2,6,5}, {2,3,7,6}, {3,0,4,7}};
static igtl_float32 attribute[8]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0};
/*** Generate test data ***/
/* Note that the size of polygon data (or other cell data) is calculated by
* number of polygons * (number of points + 1)
* '+ 1' is required because of the number of points in the polygon (uint32)
* is stored at the begining of polygon data.
*/
igtl_polydata_init_info(&info);
info.header.npoints = 8;
info.header.nvertices = 0;
info.header.size_vertices = 0;
info.header.nlines = 0;
info.header.size_lines = 0;
info.header.npolygons = 6;
info.header.size_polygons = 6 * ((4+1) * sizeof(igtl_float32));
info.header.ntriangle_strips = 0;
info.header.size_triangle_strips = 0;
info.header.nattributes = 1;
if (igtl_polydata_alloc_info(&info) == 0)
{
return EXIT_FAILURE;
}
/*** Substitute cube point data ***/
if (info.points)
{
ptr_f = info.points;
for (i = 0; i < info.header.npoints; i ++)
{
*(ptr_f++) = points[i][0];
*(ptr_f++) = points[i][1];
*(ptr_f++) = points[i][2];
}
}
else
{
return EXIT_FAILURE;
}
/*** Substitute polygon data ***/
if (info.polygons)
{
ptr_i = info.polygons;
for (i = 0; i < info.header.npolygons; i ++)
{
*(ptr_i++) = 4; /* Number of points in the polygon */
*(ptr_i++) = poly[i][0];
*(ptr_i++) = poly[i][1];
*(ptr_i++) = poly[i][2];
*(ptr_i++) = poly[i][3];
}
}
/*** Substitute attribute data ***/
if (info.attributes)
{
info.attributes[0].type = IGTL_POLY_ATTR_TYPE_SCALAR;
info.attributes[0].ncomponents = 1;
info.attributes[0].n = 8;
info.attributes[0].name = malloc(5);
strcpy(info.attributes[0].name, "attr");
info.attributes[0].data = malloc(sizeof(igtl_float32) * 8);
ptr_f = info.attributes[0].data;
for (i = 0; i < 8; i ++)
{
*(ptr_f++) = attribute[i];
}
}
/** Allocate memory for pack **/
body_size = igtl_polydata_get_size(&info, IGTL_TYPE_PREFIX_NONE);
body = malloc((igtl_uint32)body_size);
if (body == NULL)
{
igtl_polydata_free_info(&info);
return EXIT_FAILURE;
}
igtl_polydata_pack(&info, body, IGTL_TYPE_PREFIX_NONE);
/*** Set OpenIGTLink header ***/
header.version = 1;
strncpy( (char*)&(header.name), "POLYDATA", 12 );
strncpy( (char*)&(header.device_name), "DeviceName", 20 );
header.timestamp = 1234567890;
header.body_size = body_size;
header.crc = igtl_polydata_get_crc(&info, IGTL_TYPE_PREFIX_NONE, body);
igtl_header_convert_byte_order( &(header) );
/* Dumping data -- for testing */
/*
FILE *fp;
fp = fopen("polydata.bin", "w");
fwrite(&(header), IGTL_HEADER_SIZE, 1, fp);
fwrite(body, body_size, 1, fp);
fclose(fp);
*/
rh = memcmp((const void*)&header, (const void*)test_polydata_message_header, IGTL_HEADER_SIZE);
rb = memcmp((const void*)body, (const void*)test_polydata_message_body, (size_t) body_size);
igtl_polydata_free_info(&info);
free(body);
if (rh == 0 && rb == 0)
{
return EXIT_SUCCESS;
}
else
{
/* Print first 256 bytes as HEX values in STDERR for debug */
s = IGTL_HEADER_SIZE + (int)body_size;
if (s > 256)
{
s = 256;
}
fprintf(stdout, "\n===== First %d bytes of the test message =====\n", s);
igtl_message_dump_hex(stdout, (const void*)&header, s);
return EXIT_FAILURE;
}
}
