48 vrpn_int32 nCols, vrpn_int32 nRows,
51 , d_description_sent(false)
52 , d_frames_to_send(-1)
53 , d_dropped_due_to_throttle(0)
82 vrpn_float32 minVal, vrpn_float32 maxVal,
83 vrpn_float32 scale, vrpn_float32 offset)
95 "vrpn_Imager_Server::add_channel(): Scale was zero, set to 1\n");
108 const vrpn_uint16 cMin,
const vrpn_uint16 cMax,
const vrpn_uint16 rMin,
109 const vrpn_uint16 rMax,
const vrpn_uint16 dMin,
const vrpn_uint16 dMax,
110 const struct timeval *time)
114 char *msgbuf = (
char *)fbuf;
115 int buflen =
sizeof(fbuf);
116 struct timeval timestamp;
139 if ((rMax >=
d_nRows) || (rMin > rMax)) {
140 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): Invalid row "
145 if ((cMax >=
d_nCols) || (cMin > cMax)) {
146 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): Invalid "
147 "column range (%d..%d)\n",
151 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
152 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): Invalid depth "
177 vrpn_int32 len =
sizeof(fbuf) - buflen;
182 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): cannot write "
183 "message: tossing\n");
191 const vrpn_uint16 cMin,
const vrpn_uint16 cMax,
const vrpn_uint16 rMin,
192 const vrpn_uint16 rMax,
const vrpn_uint16 dMin,
const vrpn_uint16 dMax,
193 const struct timeval *time)
197 char *msgbuf = (
char *)fbuf;
198 int buflen =
sizeof(fbuf);
199 struct timeval timestamp;
207 if ((rMax >=
d_nRows) || (rMin > rMax)) {
208 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): Invalid row "
213 if ((cMax >=
d_nCols) || (cMin > cMax)) {
214 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): Invalid column "
219 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
220 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): Invalid depth "
245 vrpn_int32 len =
sizeof(fbuf) - buflen;
250 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): cannot write "
251 "message: tossing\n");
259 const struct timeval *time)
263 char *msgbuf = (
char *)fbuf;
264 int buflen =
sizeof(fbuf);
265 struct timeval timestamp;
281 vrpn_int32 len =
sizeof(fbuf) - buflen;
286 fprintf(stderr,
"vrpn_Imager_Server::send_discarded_frames(): cannot "
287 "write message: tossing\n");
321 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
322 vrpn_uint16 rMax,
const vrpn_uint8 *data, vrpn_uint32 colStride,
323 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
324 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
325 const struct timeval *time)
329 char *msgbuf =
reinterpret_cast<char *
>(fbuf);
330 int buflen =
sizeof(fbuf);
331 struct timeval timestamp;
342 if ((chanIndex < 0) || (chanIndex >=
d_nChannels)) {
343 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
344 "Invalid channel index (%d)\n",
348 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
349 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
350 "Invalid depth range (%d..%d)\n",
354 if ((rMax >=
d_nRows) || (rMin > rMax)) {
355 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
356 "Invalid row range (%d..%d)\n",
360 if ((cMax >=
d_nCols) || (cMin > cMax)) {
361 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
362 "Invalid column range (%d..%d)\n",
366 if (
static_cast<unsigned>((rMax - rMin + 1) * (cMax - cMin + 1) *
368 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
369 "Region too large (%d,%d,%d to %d,%d,%d)\n",
370 cMin, rMin, dMin, cMax, rMax, dMax);
373 if (invert_rows && (
nRows < rMax)) {
374 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
375 "nRows must not be less than rMax\n");
396 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
397 "Compression not implemented\n");
423 int cols = cMax - cMin + 1;
424 int linelen = cols *
sizeof(data[0]);
425 if (colStride == 1) {
426 for (
unsigned d = dMin; d <= dMax; d++) {
427 for (
unsigned r = rMin; r <= rMax; r++) {
430 rActual = (
nRows - 1) - r;
435 if (buflen < linelen) {
439 &data[d * depthStride + rActual * rowStride + cMin],
447 if (buflen < (
int)((dMax - dMin + 1) * (rMax - rMin + 1) *
448 (cMax - cMin + 1) *
sizeof(data[0]))) {
451 long rowStep = rowStride;
455 for (
unsigned d = dMin; d <= dMax; d++) {
457 const vrpn_uint8 *rowStart =
458 &data[d * depthStride + rMin * rowStride + cMin];
460 rowStart = &data[d * depthStride +
461 (
nRows - 1 - rMin) * rowStride + cMin];
463 const vrpn_uint8 *copyFrom = rowStart;
464 for (
unsigned r = rMin; r <= rMax; r++) {
465 for (
unsigned c = cMin; c <= cMax; c++) {
466 *
reinterpret_cast<vrpn_uint8 *
>(msgbuf) =
476 buflen -= (rMax - rMin + 1) * (cMax - cMin + 1) *
sizeof(data[0]);
482 vrpn_int32 len =
sizeof(fbuf) - buflen;
485 (
char *)(
void *)fbuf,
487 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
488 "cannot write message: tossing\n");
517 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
518 vrpn_uint16 rMax,
const vrpn_uint16 *data, vrpn_uint32 colStride,
519 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
520 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
521 const struct timeval *time)
525 char *msgbuf = (
char *)fbuf;
526 int buflen =
sizeof(fbuf);
527 struct timeval timestamp;
538 if ((chanIndex < 0) || (chanIndex >=
d_nChannels)) {
539 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
540 "Invalid channel index (%d)\n",
544 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
545 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
546 "Invalid depth range (%d..%d)\n",
550 if ((rMax >=
d_nRows) || (rMin > rMax)) {
551 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
552 "Invalid row range (%d..%d)\n",
556 if ((cMax >=
d_nCols) || (cMin > cMax)) {
557 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
558 "Invalid column range (%d..%d)\n",
562 if (
static_cast<unsigned>((rMax - rMin + 1) * (cMax - cMin + 1) *
564 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
565 "Region too large (%d,%d,%d to %d,%d,%d)\n",
566 cMin, rMin, dMin, cMax, rMax, dMax);
569 if (invert_rows && (
nRows < rMax)) {
570 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
571 "nRows must not be less than rMax\n");
592 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
593 "Compression not implemented\n");
619 int cols = cMax - cMin + 1;
620 int linelen = cols *
sizeof(data[0]);
621 if (colStride == 1) {
622 for (
unsigned d = dMin; d <= dMax; d++) {
623 for (
unsigned r = rMin; r <= rMax; r++) {
626 rActual = (
nRows - 1) - r;
631 if (buflen < linelen) {
635 &data[d * depthStride + rActual * rowStride + cMin],
643 if (buflen < (
int)((dMax - dMin + 1) * (rMax - rMin + 1) *
644 (cMax - cMin + 1) *
sizeof(data[0]))) {
647 long rowStep = rowStride;
651 for (
unsigned d = dMin; d <= dMax; d++) {
653 const vrpn_uint16 *rowStart =
654 &data[d * depthStride + rMin * rowStride + cMin];
656 rowStart = &data[d * depthStride +
657 (
nRows - 1 - rMin) * rowStride + cMin];
659 const vrpn_uint16 *copyFrom = rowStart;
660 for (
unsigned r = rMin; r <= rMax; r++) {
661 for (
unsigned c = cMin; c <= cMax; c++) {
662 memcpy(msgbuf, copyFrom,
sizeof(*copyFrom));
672 buflen -= (rMax - rMin + 1) * (cMax - cMin + 1) *
sizeof(data[0]);
676 if (vrpn_big_endian) {
677 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
682 vrpn_int32 len =
sizeof(fbuf) - buflen;
687 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
688 "cannot write message: tossing\n");
717 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
718 vrpn_uint16 rMax,
const vrpn_float32 *data, vrpn_uint32 colStride,
719 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
720 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
721 const struct timeval *time)
725 char *msgbuf = (
char *)fbuf;
726 int buflen =
sizeof(fbuf);
727 struct timeval timestamp;
738 if ((chanIndex < 0) || (chanIndex >=
d_nChannels)) {
739 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
740 "Invalid channel index (%d)\n",
744 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
745 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
746 "Invalid depth range (%d..%d)\n",
750 if ((rMax >=
d_nRows) || (rMin > rMax)) {
751 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
752 "Invalid row range (%d..%d)\n",
756 if ((cMax >=
d_nCols) || (cMin > cMax)) {
757 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
758 "Invalid column range (%d..%d)\n",
762 if (
static_cast<unsigned>((rMax - rMin + 1) * (cMax - cMin + 1) *
764 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
765 "Region too large (%d,%d,%d to %d,%d,%d)\n",
766 cMin, rMin, dMin, cMax, rMax, dMax);
769 if (invert_rows && (
nRows < rMax)) {
770 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
771 "nRows must not be less than rMax\n");
792 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
793 "Compression not implemented\n");
819 int cols = cMax - cMin + 1;
820 int linelen = cols *
sizeof(data[0]);
821 if (colStride == 1) {
822 for (
unsigned d = dMin; d <= dMax; d++) {
823 for (
unsigned r = rMin; r <= rMax; r++) {
826 rActual = (
nRows - 1) - r;
831 if (buflen < linelen) {
835 &data[d * depthStride + rActual * rowStride + cMin],
843 if (buflen < (
int)((dMax - dMin + 1) * (rMax - rMin + 1) *
844 (cMax - cMin + 1) *
sizeof(data[0]))) {
847 long rowStep = rowStride;
851 for (
unsigned d = dMin; d <= dMax; d++) {
853 const vrpn_float32 *rowStart =
854 &data[d * depthStride + rMin * rowStride + cMin];
856 rowStart = &data[d * depthStride +
857 (
nRows - 1 - rMin) * rowStride + cMin];
859 const vrpn_float32 *copyFrom = rowStart;
860 for (
unsigned r = rMin; r <= rMax; r++) {
861 for (
unsigned c = cMin; c <= cMax; c++) {
862 memcpy(msgbuf, copyFrom,
sizeof(*copyFrom));
872 buflen -= (rMax - rMin + 1) * (cMax - cMin + 1) *
sizeof(data[0]);
876 if (vrpn_big_endian) {
877 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
882 vrpn_int32 len =
sizeof(fbuf) - buflen;
887 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
888 "cannot write message: tossing\n");
918 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
919 vrpn_uint16 rMax,
const vrpn_uint8 *data, vrpn_uint32 colStride,
920 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
921 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
922 const struct timeval *time)
931 const vrpn_uint8 *new_base =
932 data - (cMin + rowStride * rMin + depthStride * dMin);
934 chanIndex, cMin, cMax, rMin, rMax, new_base, colStride, rowStride,
935 nRows, invert_rows, depthStride, dMin, dMax, time)) {
939 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_first_pointer():"
940 " Call to send using offset base_pointer failed.\n");
968 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
969 vrpn_uint16 rMax,
const vrpn_uint16 *data, vrpn_uint32 colStride,
970 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
971 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
972 const struct timeval *time)
981 const vrpn_uint16 *new_base =
982 data - (cMin + rowStride * rMin + depthStride * dMin);
984 chanIndex, cMin, cMax, rMin, rMax, new_base, colStride, rowStride,
985 nRows, invert_rows, depthStride, dMin, dMax, time)) {
989 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_first_pointer():"
990 " Call to send using offset base_pointer failed.\n");
1018 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
1019 vrpn_uint16 rMax,
const vrpn_float32 *data, vrpn_uint32 colStride,
1020 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
1021 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
1022 const struct timeval *time)
1031 const vrpn_float32 *new_base =
1032 data - (cMin + rowStride * rMin + depthStride * dMin);
1034 chanIndex, cMin, cMax, rMin, rMax, new_base, colStride, rowStride,
1035 nRows, invert_rows, depthStride, dMin, dMax, time)) {
1039 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_first_pointer():"
1040 " Call to send using offset base_pointer failed.\n");
1049 char *msgbuf = (
char *)fbuf;
1050 int buflen =
sizeof(fbuf);
1051 struct timeval timestamp;
1060 fprintf(stderr,
"vrpn_Imager_Server::send_description(): Can't pack "
1061 "message header, tossing\n");
1065 if (!
d_channels[i].buffer(&msgbuf, &buflen)) {
1066 fprintf(stderr,
"vrpn_Imager_Server::send_description(): Can't "
1067 "pack message channel, tossing\n");
1074 vrpn_int32 len =
sizeof(fbuf) - buflen;
1080 fprintf(stderr,
"vrpn_Imager_Server::send_description(): cannot write "
1081 "message: tossing\n");
1095 "vrpn_Imager_Server::set_resolution(): Invalid size (%d, %d, %d)\n",
1117 const char *bufptr = p.
buffer;
1121 vrpn_int32 frames_to_send;
1129 if (frames_to_send < 0) {
1163 , d_got_description(false)
1213 const char *bufptr = p.
buffer;
1241 const char *bufptr = p.
buffer;
1259 fprintf(stderr,
"vrpn_Imager_Remote::handle_region_message(): Can't "
1260 "unbuffer parameters!\n");
1270 fprintf(stderr,
"vrpn_Imager_Remote::handle_region_message(): "
1271 "Compression not implemented\n");
1293 const char *bufptr = p.
buffer;
1301 fprintf(stderr,
"vrpn_Imager_Remote::handle_begin_frame_message(): "
1302 "Can't unbuffer parameters!\n");
1319 const char *bufptr = p.
buffer;
1327 fprintf(stderr,
"vrpn_Imager_Remote::handle_end_frame_message(): Can't "
1328 "unbuffer parameters!\n");
1345 const char *bufptr = p.
buffer;
1351 fprintf(stderr,
"vrpn_Imager_Remote::handle_discarded_frames_message():"
1352 " Can't unbuffer parameters!\n");
1381 char *msgbuf = (
char *)fbuf;
1382 int buflen =
sizeof(fbuf);
1383 struct timeval timestamp;
1387 fprintf(stderr,
"vrpn_ImagerPose_Server::throttle_sender(): Can't pack "
1388 "message header, tossing\n");
1394 vrpn_int32 len =
sizeof(fbuf) - buflen;
1400 fprintf(stderr,
"vrpn_ImagerPose_Server::throttle_sender(): cannot "
1401 "write message: tossing\n");
1442 vrpn_uint8 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride,
1443 vrpn_uint32 depthStride, vrpn_uint16 nRows,
bool invert_rows,
1444 unsigned repeat)
const
1447 if (colStride < repeat) {
1448 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1449 "pointer(): colStride must be >= repeat\n");
1453 if (invert_rows && (nRows <
d_rMax)) {
1454 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1455 "pointer(): nRows must not be less than _rMax\n");
1474 int linelen = cols *
sizeof(data[0]);
1475 if ((colStride == 1) && (repeat == 1)) {
1476 const vrpn_uint8 *msgbuf = (
const vrpn_uint8 *)
d_valBuf;
1481 rActual = (nRows - 1) - r;
1487 &data[d * depthStride + rActual * rowStride +
d_cMin],
1494 long rowStep = rowStride;
1498 const vrpn_uint8 *msgbuf = (
const vrpn_uint8 *)
d_valBuf;
1500 vrpn_uint8 *rowStart =
1501 &data[d * depthStride +
d_rMin * rowStride +
1504 rowStart = &data[d * depthStride +
1505 (nRows - 1 -
d_rMin) * rowStride +
1508 vrpn_uint8 *copyTo = rowStart;
1511 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1519 rowStart += rowStep;
1533 if (vrpn_big_endian) {
1534 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
1538 long rowStep = rowStride;
1542 const vrpn_float32 *msgbuf = (
const vrpn_float32 *)
d_valBuf;
1544 vrpn_uint8 *rowStart =
1545 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1548 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1551 vrpn_uint8 *copyTo = rowStart;
1554 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1555 *(copyTo + rpt) =
static_cast<vrpn_uint8
>(
1559 copyTo += colStride;
1561 rowStart += rowStep;
1569 long rowStep = rowStride;
1573 const vrpn_uint16 *msgbuf = (
const vrpn_uint16 *)
d_valBuf;
1575 vrpn_uint8 *rowStart =
1576 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1579 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1582 vrpn_uint8 *copyTo = rowStart;
1585 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1586 *(copyTo + rpt) =
static_cast<vrpn_uint8
>(
1591 copyTo += colStride;
1593 rowStart += rowStep;
1599 printf(
"vrpn_Imager_Region::decode_unscaled_region_using_base_pointer()"
1600 ": Transcoding not implemented yet for this type\n");
1611 vrpn_uint16 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride,
1612 vrpn_uint32 depthStride, vrpn_uint16 nRows,
bool invert_rows,
1613 unsigned repeat)
const
1616 if (colStride < repeat) {
1617 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1618 "pointer(): colStride must be >= repeat\n");
1621 if (invert_rows && (nRows <
d_rMax)) {
1622 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1623 "pointer(): nRows must not be less than _rMax\n");
1644 int linelen = cols *
sizeof(data[0]);
1645 if ((colStride == 1) && (repeat == 1)) {
1646 const vrpn_uint16 *msgbuf = (
const vrpn_uint16 *)
d_valBuf;
1651 rActual = (nRows - 1) - r;
1657 &data[d * depthStride + rActual * rowStride +
d_cMin],
1664 long rowStep = rowStride;
1668 const vrpn_uint16 *msgbuf = (
const vrpn_uint16 *)
d_valBuf;
1670 vrpn_uint16 *rowStart =
1671 &data[d * depthStride +
d_rMin * rowStride +
1674 rowStart = &data[d * depthStride +
1675 (nRows - 1 -
d_rMin) * rowStride +
1678 vrpn_uint16 *copyTo = rowStart;
1681 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1689 rowStart += rowStep;
1705 long rowStep = rowStride;
1709 const vrpn_uint8 *msgbuf = (
const vrpn_uint8 *)
d_valBuf;
1711 vrpn_uint16 *rowStart =
1712 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1715 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1718 vrpn_uint16 *copyTo = rowStart;
1721 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1724 (
static_cast<vrpn_uint16
>(*msgbuf) << 8);
1727 copyTo += colStride;
1729 rowStart += rowStep;
1735 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1736 "pointer(): XXX Transcoding this type not yet "
1742 if (vrpn_big_endian) {
1743 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
1751 vrpn_float32 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride,
1752 vrpn_uint32 depthStride, vrpn_uint16 nRows,
bool invert_rows,
1753 unsigned repeat)
const
1756 if (colStride < repeat) {
1757 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1758 "pointer(): colStride must be >= repeat\n");
1765 printf(
"vrpn_Imager_Region::decode_unscaled_region_using_base_pointer()"
1766 ": Transcoding not implemented yet\n");
1769 if (invert_rows && (nRows <
d_rMax)) {
1770 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1771 "pointer(): nRows must not be less than _rMax\n");
1785 int linelen = cols *
sizeof(data[0]);
1786 if ((colStride == 1) && (repeat == 1)) {
1787 const vrpn_float32 *msgbuf = (
const vrpn_float32 *)
d_valBuf;
1792 rActual = (nRows - 1) - r;
1797 memcpy(&data[d * depthStride + rActual * rowStride +
d_cMin],
1804 long rowStep = rowStride;
1808 const vrpn_float32 *msgbuf = (
const vrpn_float32 *)
d_valBuf;
1810 vrpn_float32 *rowStart =
1811 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1814 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1817 vrpn_float32 *copyTo = rowStart;
1820 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1821 *(copyTo + rpt) = *msgbuf;
1824 copyTo += colStride;
1826 rowStart += rowStep;
1833 if (vrpn_big_endian) {
1834 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
1866 vrpn_uint16 col, vrpn_uint16 row,
1870 if (center == NULL) {
1873 "vrpn_ImagerPose::compute_pixel_center(): NULL center pointer\n");
1878 if ((col >= image.
nCols()) || (row >= image.
nRows()) ||
1879 (depth >= image.
nDepth())) {
1880 fprintf(stderr,
"vrpn_ImagerPose::compute_pixel_center(): Pixel index "
1892 vrpn_float64 stepC = 1.0 / image.
nCols();
1893 vrpn_float64 stepR = 1.0 / image.
nRows();
1894 vrpn_float64 stepD = 1.0 / image.
nDepth();
1897 (0.5 + row) * stepR *
d_dRow[0] +
1898 (0.5 + depth) * stepD *
d_dDepth[0];
1900 (0.5 + row) * stepR *
d_dRow[1] +
1901 (0.5 + depth) * stepD *
d_dDepth[1];
1903 (0.5 + row) * stepR *
d_dRow[2] +
1904 (0.5 + depth) * stepD *
d_dDepth[2];
1910 const char *name,
const vrpn_float64 origin[3],
const vrpn_float64 dCol[3],
1911 const vrpn_float64 dRow[3],
const vrpn_float64 *dDepth,
vrpn_Connection *c)
1917 if (dDepth != NULL) {
1934 const vrpn_float64 dCol[3],
1935 const vrpn_float64 dRow[3],
1936 const vrpn_float64 *dDepth)
1941 if (dDepth != NULL) {
1951 char *msgbuf = (
char *)fbuf;
1952 int buflen =
sizeof(fbuf);
1953 struct timeval timestamp;
1969 fprintf(stderr,
"vrpn_ImagerPose_Server::send_description(): Can't "
1970 "pack message header, tossing\n");
1976 vrpn_int32 len =
sizeof(fbuf) - buflen;
1982 fprintf(stderr,
"vrpn_ImagerPose_Server::send_description(): cannot "
1983 "write message: tossing\n");
2012 const char *bufptr = p.
buffer;