def computeAveragePhases(camsys, fileName, window=4, cx=0, cy=0):
""" Computes the average phases for a given file. Uses simple average for getting phase value """
r = Voxel.FrameStreamReader(fileName, camsys)
if not cx:
bool3, cx = r.getStreamParamf("cx")
if not bool3:
cx = 0
if not cy:
bool4, cy = r.getStreamParamf("cy")
if not bool4:
cy = 0
cx = int(cx)
cy = int(cy)
phases, amplitudes, frames, rows, cols = extractPhasesandAmplitudes(
fileName, camsys)
if cx == 0:
cx = rows / 2
if cy == 0:
cy = cols / 2
centerShape = [
cx - window / 2, cx + window / 2, cy - window / 2, cy + window / 2
]
averagePhases = np.zeros([window, window], dtype='float')
for val in np.arange(frames):
phaseWindow = phases[val][centerShape[0]:centerShape[1],
centerShape[2]:centerShape[3]]
averagePhases += phaseWindow
averagePhases = averagePhases / frames
averagePhases = np.mean(averagePhases)
return averagePhases, rows, cols
def read(vxlFile, cameraInfo):
reader = Voxel.FrameStreamReader(vxlFile, cameraInfo.system)
if not reader.isStreamGood():
raise ValueError("Stream is not good: " + vxlFile)
frames = list()
for i in range(reader.size()):
if not reader.readNext():
raise ValueError("Failed to read frame number " + str(i))
rawProcessedFrame = Voxel.ToF1608Frame.typeCast(
reader.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_PROCESSED])
depthFrame = Voxel.DepthFrame.typeCast(
reader.frames[Voxel.DepthCamera.FRAME_DEPTH_FRAME])
attributes = {
"ambient":
np.array(rawProcessedFrame._ambient,
copy=True).reshape(cameraInfo.resolution),
"amplitude":
np.array(rawProcessedFrame._amplitude,
copy=True).reshape(cameraInfo.resolution),
"phase":
np.array(rawProcessedFrame._phase,
copy=True).reshape(cameraInfo.resolution),
"depth":
np.array(depthFrame.depth,
copy=True).reshape(cameraInfo.resolution)
}
frames.append(VxlFrame(attributes))
reader.close()
return VxlVideo(frames)
def vxltoPng(filename):
"""Converts VXL file to a PNG using amplitude data. Uses open cv libraries"""
camsys = Voxel.CameraSystem()
r = Voxel.FrameStreamReader(filename, camsys)
bool1, cols = r.getStreamParamu("frameWidth")
bool2, rows = r.getStreamParamu("frameHeight")
if not bool1 or not bool2:
print("Cannot read the stream")
if not r.isStreamGood():
print("Stream is not good: " + filename)
numFrames = r.size()
meanAmplitudes = np.zeros((rows, cols), dtype='float')
for i in (range(numFrames)):
if not r.readNext():
print("Failed to read frame %d" % i)
break
tofFrame = Voxel.ToF1608Frame.typeCast(
r.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_PROCESSED])
meanAmplitudes += np.array(tofFrame._amplitude, copy=True).reshape(
(rows, cols))
r.close()
meanAmplitudes = meanAmplitudes / np.max(meanAmplitudes) * 255
outFileName = os.path.splitext(filename)[0] + '.png'
cv2.imwrite(outFileName, meanAmplitudes.astype(np.uint8))
def __init__(self, filename, cameraSystem):
super(FileStreamSource, self).__init__(os.path.basename(filename))
self.filename = filename
self.runThread = None
self.running = False
self.cameraSystem = cameraSystem
self.frameStream = Voxel.FrameStreamReader(str(filename), cameraSystem)
self.frameStreamHandler = self.frameStream
def computeAveragePhases(camsys, filename, window=0):
"""Returns the average phases for all pixels for a given file"""
r = Voxel.FrameStreamReader(filename, camsys)
bool1, cols = r.getStreamParamu("frameWidth")
bool2, rows = r.getStreamParamu("frameHeight")
_, cx = r.getStreamParamf('cx')
_, cy = r.getStreamParamf('cy')
_, fx = r.getStreamParamf('fx')
_, fy = r.getStreamParamf('fy')
_, k1 = r.getStreamParamf('k1')
_, k2 = r.getStreamParamf('k2')
_, k3 = r.getStreamParamf('k3')
_, p1 = r.getStreamParamf('p1')
_, p2 = r.getStreamParamf('p2')
cx = int(cx)
cy = int(cy)
if cx == 0:
cx = rows / 2
if cy == 0:
cy = cols / 2
if window:
centerShape = [
cx - window / 2, cx + window / 2, cy - window / 2, cy + window / 2
]
else:
centerShape = [0, rows, 0, cols]
if not r.isStreamGood() or not bool1 or not bool2:
print("Stream is not good: " + filename)
numFrames = r.size()
if window:
averagePhase = np.zeros((window, window), dtype='complex')
else:
averagePhase = np.zeros((rows, cols), dtype='complex')
for i in np.arange(numFrames):
if not r.readNext():
print("Failed to read frame %d" % i)
break
tofFrame = Voxel.ToF1608Frame.typeCast(
r.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_PROCESSED])
phase = np.array(tofFrame._phase, copy=True).reshape((rows, cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]*2*np.pi/4096
amplitude = np.array(tofFrame._amplitude, copy = True).reshape((rows,cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]
averagePhase += amplitude * (np.cos(phase) + 1j * np.sin(phase))
averagePhase /= numFrames
if window:
averagePhase = np.sum(averagePhase) / (window * window)
if averagePhase < 0:
averagePhase += 4096
averagePhase = np.angle(averagePhase) * 4096 / (2 * np.pi)
r.close()
dist = np.array([k1, k2, k3, p1, p2])
mtx = np.array([[fx, 0, cx], [0, fy, cy], [0, 0, 1]])
return averagePhase, rows, cols, mtx, dist
def computeAveragePhases(camsys, filename, cx=0, cy=0, window=4):
""" Computes the average phases for a given file. Uses the complex average for getting phase value """
r = Voxel.FrameStreamReader(filename, camsys)
bool1, cols = r.getStreamParamu("frameWidth")
bool2, rows = r.getStreamParamu("frameHeight")
if not cx:
bool3, cx = r.getStreamParamf("cx")
if not bool3:
cx = 0
if not cy:
bool4, cy = r.getStreamParamf("cy")
if not bool4:
cy = 0
cx = int(cx)
cy = int(cy)
if cx == 0:
cx = rows / 2
if cy == 0:
cy = cols / 2
if window:
centerShape = [
cx - window / 2, cx + window / 2, cy - window / 2, cy + window / 2
]
else:
centerShape = [0, rows, 0, cols]
if not r.isStreamGood() or not bool1 or not bool2:
print("Stream is not good: " + filename)
numFrames = r.size()
if window:
averagePhase = np.zeros((window, window), dtype='complex')
else:
averagePhase = np.zeros((rows, cols), dtype='complex')
for i in np.arange(numFrames):
if not r.readNext():
print("Failed to read frame %d" % i)
break
tofFrame = Voxel.ToF1608Frame.typeCast(
r.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_PROCESSED])
phase = np.array(tofFrame._phase, copy=True).reshape((rows, cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]*2*np.pi/4096
amplitude = np.array(tofFrame._amplitude, copy = True).reshape((rows,cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]
averagePhase += amplitude * (np.cos(phase) + 1j * np.sin(phase))
averagePhase /= numFrames
if window:
averagePhase = np.sum(averagePhase) / (window * window)
averagePhase = np.angle(averagePhase) * 4096 / (2 * np.pi)
r.close()
return averagePhase, rows, cols
def extractRawdataFromVXL(filename, camsys):
"""Takes raw data from vxl file"""
r = Voxel.FrameStreamReader(filename, camsys)
if not r.isStreamGood():
print("Stream is not good: " + filename)
bool1, cols = r.getStreamParamu("frameWidth")
bool2, rows = r.getStreamParamu("frameHeight")
numFrames = r.size()
rawFrames = np.zeros((numFrames, rows * cols * 4), dtype='uint8')
for i in (range(numFrames)):
if not r.readNext():
print("Failed to read frame %d" % i)
break
rawFrame = Voxel.RawDataFrame.typeCast(
r.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_UNPROCESSED])
rawFrames[i] = np.array(rawFrame.data, copy=True)[:-255]
return rawFrames, rows, cols
import numpy as np
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-f",
"--file",
type=str,
help="Voxel file (.vxl)",
required=True)
args = parser.parse_args()
camsys = Voxel.CameraSystem()
r = Voxel.FrameStreamReader(args.file, camsys)
iAverage = None
qAverage = None
frameCount = 0
if not r.isStreamGood():
print 'Could not open stream'
sys.exit(1)
print 'Stream contains ', r.size(), ' frames'
count = r.size()
for i in range(0, count):
if not r.readNext():
def computeHDRAveragePhases(camsys,
filename,
cx=0,
cy=0,
window=4,
chipset='TintinCDKCamera'):
""" Computes average phases for the HDR frame"""
r = Voxel.FrameStreamReader(filename, camsys)
_, cols = r.getStreamParamu("frameWidth")
_, rows = r.getStreamParamu("frameHeight")
if not cx:
_, cx = r.getStreamParamf('cx')
if not cy:
_, cy = r.getStreamParamf('cy')
cx = int(cx)
cy = int(cy)
if cx == 0:
cx = rows / 2
if cy == 0:
cy = cols / 2
if window:
centerShape = [
cx - window / 2, cx + window / 2, cy - window / 2, cy + window / 2
]
averagePhase = np.zeros((window, window), dtype='complex')
else:
centerShape = [0, rows, 0, cols]
averagePhase = np.zeros((rows, cols), dtype='complex')
if not r.isStreamGood():
print("Stream is not good: " + filename)
numFrames = r.size()
if chipset == 'TintinCDKCamera':
for i in np.arange(numFrames):
if not r.readNext():
print("Failed to read frame %d" % i)
break
tofFrame = Voxel.ToF1608Frame.typeCast(
r.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_PROCESSED])
flag = np.array(tofFrame._flags, copy=True)[0]
if flag & 0x04 == 0x04:
phase = np.array(tofFrame._phase, copy=True).reshape((rows, cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]*2*np.pi/4096
averagePhase += np.array(tofFrame._amplitude, copy = True).reshape((rows,cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]*(np.cos(phase)+ 1j*np.sin(phase))
if np.sum(np.absolute(averagePhase)) == 0:
print("no HDR frames received")
return False, 0, 0, 0
averagePhase /= numFrames
if window:
averagePhase = np.sum(averagePhase) / (window * window)
averagePhase = np.angle(averagePhase) * 4096 / (2 * np.pi)
r.close()
if chipset == 'CalculusCDKCamera':
tofFrame = Voxel.ToF1608Frame.typeCast(
r.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_PROCESSED])
flagFirst = np.array(tofFrame._flags, copy=True)[0]
amplitudeFirst = np.array(tofFrame._amplitude, copy=True)
if not r.readNext():
print("Failed to read frame 2")
flagSecond = np.array(tofFrame._flags, copy=True)[0]
amplitudeSecond = np.array(tofFrame._amplitude, copy=True)
if np.mean(amplitudeFirst) > np.mean(amplitudeSecond):
flagVal = flagSecond
else:
flagVal = flagFirst
if flagVal == 0x02 or flagVal == 0x03:
flagVal = flagVal - 2
for i in np.arange(numFrames):
if not r.readNext():
print("Failed to read frame %d" % i)
break
tofFrame = Voxel.ToF1608Frame.typeCast(
r.frames[Voxel.DepthCamera.FRAME_RAW_FRAME_PROCESSED])
flag = np.array(tofFrame._flags, copy=True)[0]
if flag == flagVal or flag == flagVal + 2:
phase = np.array(tofFrame._phase, copy=True).reshape((rows, cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]*2*np.pi/4096
averagePhase += np.array(tofFrame._amplitude, copy = True).reshape((rows,cols))\
[centerShape[0]:centerShape[1], centerShape[2]:centerShape[3]]*(np.cos(phase)+ 1j*np.sin(phase))
if np.sum(np.absolute(averagePhase)) == 0:
print("no HDR frames received")
return False, 0, 0, 0
averagePhase /= numFrames
if window:
averagePhase = np.sum(averagePhase) / (window * window)
averagePhase = np.angle(averagePhase) * 4096 / (2 * np.pi)
r.close()
return True, averagePhase, rows, cols
