top of page

FAQ

1) Does OctoView support 3D Mapping sensors?

  • For 3D mapping sensors, please contact the Blue Ring team.

  • Any imaging sensor which is broadcast as a video stream we can display following the video information above is provided.

2) What Headsets Does OctoView Support?

  • OctoView is currently Compatible with the Meta Quest Pro, and Quest 2 with support for the HTC Vive Elite coming in Q2 2023.

3) What is the Highest Framerate OctoView can support?

  • The highest frame rate supported is 120Hz.

4) What is the Maximum Resolution is Recommended for OctoView?

  • The highest resolution supported is 4k.

5) Is Nausea a Factor when using OctoView on boats?

  • We have done extensive ocean testing in a 12 ft Zodiac with 1-4 ft seas and found nausea to not be a concern across multiple people of varying seasickness tolerances. A general rule of thumb to follow is if you are not prone to seasickness then operating OctoView will not be a concern.

6) What is the Glass to Glass Latency?

  • The target latency from cameras to OctoView display is 10ms. This number can vary depending on the number of cameras, resolution, and required framerate.

7) Is Sunlight an Issue with Head Mounted Displays?

  • Depending on the headset sunlight may be a factor in head movement tracking. Headsets which have low-light cameras or depend on infrared information (such as the Meta Quest 2) will not work outside. Alternatively, higher end headsets such as the Meta Quest Pro or the Magic Leap 2 use IR filtered optical tracking and do not suffer from tracking loss due to the Sun.

8) What are the Compute Requirements for OctoView?

  • Currently OctoView runs on a PC and displays on the headset via a USBC or WiFi connection. The PC running OctoView must have an NVIDIA 3080 or higher GPU to maintain a 10ms latency. 

  • Depending on the customer’s mission set, OctoView can also be used as a standalone device but there is an NRE cost associated with setting up a particular headset for this task.

9) Does OctoView store any data?

  • OctoView may store meta data associated with human/system performance including headset pose, frequency of button presses, error reports, and they type of commands executed. OctoView does not store any video or imaging data and thus does not have any minimum memory requirement for the PC.​

10) Can OctoView be viewed on a traditional 2D display?

  • Yes, if no headset is connected then OctoView will display in a video wall format which can be viewed through an HDMI port connected to the PC​.

How Do I Get Started?

All we need to get started is access to your video feed and telemetry stream.

Video Stream Requirements

  • Sensor Data Type: Camera, Sonar, Radar, etc

  • RTSP or RTP video streams

  • Encoding Scheme: H264 or H265

  • Minimum Recommended Image Quality Settings:

    • 30 FPS

    • 1920 x 1080

OctoView Telemetry API

  • OctoView uses a simple UDP byte stream to ingest telemetry which can be configured to match the subnet of your network.

  • To send telemetry into OctoView simply create a byte stream following the following order:

ce02c5_55d80c955aa54e6b93ae1026c1f744b1_mv2.webp

Below is a python example showing how to properly format telemetry and send to OctoView.

import time
import argparse
import socket
from datetime import datetime

ip = '192.168.1.202'
port = 8000

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((ip, port))
s.setblocking(0)

type_map = [    ('roll', 'degrees'),
                ('pitch', 'degrees'),                    
                ('heading', 'degrees'),                   
                ('northing', 'float'),                 
                ('easting', 'float'),       
                ('bottom_lock', 'boolean'),               
                ('depth', 'meters'),                     
                ('altitude', 'meters'),                  
                ('speed', 'meters/second'),                     
                ('latitude', 'float'),                  
                ('longitude', 'float'),                 
                ('pressure', 'psi'),                  
                ('temperature', 'fahrenheit'),               
                ('velocity_north', 'meters/second'),            
                ('velocity_east', 'meters/second'),             
                ('velocity_down', 'meters/second'),             
                ('pitch_lock_enabled', 'boolean'),        
                ('roll_lock_enabled', 'boolean'),         
                ('heading_lock_enabled', 'boolean'),      
                ('depth_lock_enabled', 'boolean'),        
                ('altitude_lock_enabled', 'boolean'),     
                ('latitude_lock_enabled', 'boolean'),     
                ('longitude_lock_enabled', 'boolean'),    
                ('pitch_lock_value', 'degrees'),          
                ('roll_lock_value', 'degrees'),           
                ('heading_lock_value', 'degrees'),        
                ('depth_lock_value', 'meters'),          
                ('altitude_lock_value', 'meters'),       
                ('latitude_lock_value', 'float'),       
                ('longitude_lock_value', 'float'),      
                ('timestamp', 'integer')
            ]                 

data_dict = {   'roll'                      : 0.0,
                'pitch'                     : 0.0,
                'heading'                   : 0.0,
                'northing'                  : 0.0,
                'easting'                   : 0.0,
                'bottom_lock'               : False,
                'depth'                     : 0.0,
                'altitude'                  : 0.0,
                'speed'                     : 0.0,
                'latitude'                  : 0.0,
                'longitude'                 : 0.0,
                'pressure'                  : 0.0,
                'temperature'               : 0.0,
                'velocity_north'            : 0.0,
                'velocity_east'             : 0.0,
                'velocity_down'             : 0.0,
                'pitch_lock_enabled'        : False,
                'roll_lock_enabled'         : False,
                'heading_lock_enabled'      : False,
                'depth_lock_enabled'        : False,
                'altitude_lock_enabled'     : False,
                'latitude_lock_enabled'     : False,
                'longitude_lock_enabled'    : False,
                'pitch_lock_value'          : 0.0,
                'roll_lock_value'           : 0.0,
                'heading_lock_value'        : 0.0,
                'depth_lock_value'          : 0.0,
                'altitude_lock_value'       : 0.0,
                'latitude_lock_value'       : 0.0,
                'longitude_lock_value'      : 0.0,
                'timestamp'                 : 0       
        }

def get_udp_string():
    string = ""
    for item in type_map:
        label = item[0]
        value = data_dict[label]
        string += label + ":" + str(value) + ","
    return string

def send_telemetry_to_udp():
    print("Sending telemetry to UDP...")
    send_data = get_udp_string()
    s.sendto(send_data.encode('utf-8'), ('192.168.1.221', 9000))

 

while True:
    send_telemetry_to_udp()
    time.sleep(1)

bottom of page