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 commonPhaseOffset(file1,
distance,
modFreq1,
cx,
cy,
file2=None,
modFreq2=None,
window=4,
chipset='ti.tinitn'):
c = 299792458 # m/s
camsys = Voxel.CameraSystem()
averagePhase1, rows, cols = computeAveragePhases(
camsys, file1, cx, cy, window) #default window size = 4
ds1 = c / (2 * modFreq1 * 1E6)
phaseActual1 = distance / ds1 * 4096
phaseAverage1 = averagePhase1
phaseCorr = wrapPhaseToSignedInteger(int(phaseAverage1 - phaseActual1))
if file2 and modFreq2:
averagePhase2, rows, cols = computeAveragePhases(
camsys, file2, cx, cy, window)
ds2 = c / (2 * modFreq2 * 1E6)
phaseActual2 = distance / ds2 * 4096
phaseAverage2 = averagePhase2
phaseCorr2 = wrapPhaseToSignedInteger(int(phaseAverage2 -
phaseActual2))
else:
phaseCorr2 = 0
if chipset == 'ti.calculus': #additive phase
phaseCorr = -phaseCorr
phaseCorr2 = -phaseCorr2
return True, phaseCorr, phaseCorr2, 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 Getraws(npyDir):
# Read the images and concatenate
images = []
filenames = []
for dirName, subdirList, fileList in os.walk(npyDir):
# Sort the tif file numerically
fileList = natsort.natsorted(fileList)
for f in fileList:
if f.endswith(".bin"):
filename, file_extension = os.path.splitext(f)
fullpath = os.path.join(npyDir, f)
print filename
# check!
pVoxel = vx.PyVoxel()
#pVoxel.ReadFromRaw(fullpath)
pVoxel.ReadFromBin(fullpath)
#pVoxel.Normalize()
images.append(pVoxel.m_Voxel)
filenames.append(filename)
return images, filenames
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 __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 selectConfFile(self):
self.confFile, _ = QtGui.QFileDialog.getOpenFileName(
self, "Select Conf File", filter='Conf files (*.conf)')
if self.confFile:
config = Voxel.ConfigurationFile()
ret = config.read(str(self.confFile))
if ret:
self.calibrationWizard.previousConfiguration = config
self.complete = True
self.completeChanged.emit()
def setPreviousConfiguration(self, id):
c = self.depthCamera.configFile.getCameraProfile(id)
if not c:
QtGui.QMessageBox.critical(
self, 'Calibration Wizard',
'Could not get configuration for camera profile "' +
self.depthCamera.getCurrentCameraProfileID() + '"')
return
self.previousConfiguration = Voxel.ConfigurationFile(c)
self.previousProfileID = self.depthCamera.getCurrentCameraProfileID()
def __init__(self):
super(CalibrationWizard, self).__init__()
# self.depthCamera = Voxel.DepthCamera()
self.cameraSystem = Voxel.CameraSystem()
self.devices = self.cameraSystem.scan()
if self.devices:
self.depthCamera = self.cameraSystem.connect(self.devices[0])
else:
self.depthCamera = None
ret, self.profilePath = Voxel.Configuration().getLocalPath('profiles')
self.configPath = os.getcwd() + os.sep + '..'
# self.editIndex = editIndex
self.setMinimumHeight(600)
self.setMinimumWidth(400)
self.setWizardStyle(QtGui.QWizard.ModernStyle)
self.setWindowTitle('Calibration Wizard')
self.addPage(CalibrationInitPage(self))
self.addPage(CalibrationSelectPage(self))
self.profileName = None
self.calibs = OrderedDict()
self.paths = {}
self.dataCapture = []
self.pages = {}
self.calibParams = {}
self.chipset = None
self.previousConfiguration = []
self.previousConfigurations = {}
self.calibPages = [('lens', CalibrationLensPage(self)),
('capture', CalibrationDataCapturePage(self)),
('nonLinearity', CalibrationNonLinearityPage(self)),
('temperature', CalibrationTemperaturePage(self)),
('commonPhase', CalibrationCommonPhasePage(self)),
('hdrCommonPhase',
CalibrationHDRCommonPhasePage(self)),
('perPixel', CalibrationPerPixelOffsetPage(self))]
for name, page in self.calibPages:
self.addCalibrationPage(name, page)
self.addPage(CalibrationConclusionPage(self))
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 __init__(self, chipset, profile):
self.config = None
self.chipset = chipset
super (WriteConfigFile, self). __init__()
self.chipsetName = chipset + 'CDKCamera'
self.profile = profile + '.conf'
c = Voxel.Configuration()
ret, path = c.getLocalConfPath()
self.confFile = path + os.sep + self.chipsetName + self.profile
if not os.path.isfile(self.confFile):
self.configBase()
else:
self.config = ConfigParser()
self.config.read(self.confFile)
def __init__(self, cameraSystem):
print("MainWindow init")
self.depthCamera = cameraSystem.connect(devices[0])
rate = Voxel.FrameRate()
rate.numerator = 5
rate.denominator = 1
self.depthCamera.setFrameRate(rate)
if self.depthCamera:
self.depthCamera.clearAllCallbacks()
self.depthCamera.registerCallback(
Voxel.DepthCamera.FRAME_DEPTH_FRAME, self.callbackInternal)
if not self.depthCamera.start():
print(" start fail")
else:
print(" start ok")
def perPixelOffset(fileName, pathToSave=None, profileName=None):
"""Computes pixelwise phase offset for all pixels. Returns a numpy file containing the pixelwise offsets as well as the bin file
.. note: Copy the bin file to the /path/to/.voxel/conf folder path before using it in the conf file
"""
camsys = Voxel.CameraSystem()
if not profileName:
profileName = os.path.basename(fileName).split('.')[0]
ret = computeAveragePhases(camsys, fileName, 0)
if not ret:
print "Can't calculate the phase offsets. Check file"
sys.exit()
else:
phases, rows, cols, mtx, dist = ret
if pathToSave is None:
newFile = os.path.splitext(fileName)[0] + PHASE_FILENAME
else:
newFile = pathToSave + profileName + PHASE_FILENAME
np.save(newFile, phases.T)
cGrid = np.mgrid[0:rows, 0:cols].astype(np.float32)
cGrid1D = np.reshape(np.transpose(cGrid, (1, 2, 0)),
(rows * cols, 1, 2)).astype(np.float32)
cGridCorrected1D = cv2.undistortPoints(cGrid1D, mtx, dist)
cGridCorrected = np.transpose(
np.reshape(cGridCorrected1D, (rows, cols, 2)), (2, 0, 1))
ry = cGridCorrected[0]
rx = cGridCorrected[1]
# Uncomment to get undistortion mapping
#with open('temp2.txt', 'w') as f:
#for r in range(0, self.rows):
#for c in range(0, self.columns):
#f.write('(%d, %d) -> (%.2f, %.2f)\n'%(self.cGrid[1, r, c], self.cGrid[0, r, c], rx[r, c], ry[r, c]))
rad2DSquare = ((rx**2) + (ry**2))
cosA = 1 / ((rad2DSquare + 1)**0.5)
deltaPhase = phases - phases[int(mtx[0, 2]), int(mtx[1, 2])] / cosA
if pathToSave is None:
phaseOffsetFileName = os.path.splitext(fileName)[0] + PHASE_OFFSET_FILE
else:
phaseOffsetFileName = pathToSave + os.sep + profileName + PHASE_OFFSET_FILE
with open(phaseOffsetFileName, 'wb') as f:
f.write(struct.pack('H', rows))
f.write(struct.pack('H', cols))
f.write(struct.pack('H', 0))
np.reshape(deltaPhase, rows * cols).astype(np.short).tofile(f)
return True, phaseOffsetFileName, rows, cols
def commonPhaseOffset(file1,
distance,
modFreq1,
cx,
cy,
file2=None,
modFreq2=None,
window=4,
chipset='ti.tinitn'):
""" Computes the common phase offsets.
This function calculates the common phase offsets for a given file, taking VXL as input.
**Parameters**::
- file1, file2: File(s) for computing common phase offsets. These should be vxl files of a flat wall. The camera should be almost parallel to the wall.
- modFreq1, modFreq2 : Modulation Frequency (ies) when the data is captured. If dealiasing is enabled, two modulation frequencies are required
- cx, cy: The coordinates of the center pixel, found during lens calibration. If cx and cy are not available, the central value (120,160) is taken.
- window: The window size. By default, a window of 4x4 is required.
- chipset: The chipset being used.
**Returns**::
- phase_Corr1: Phase offset value for the first modulation frequency
- phase_Corr2: Phase offset value for the second modulation frequency
"""
c = 299792458 # m/s
camsys = Voxel.CameraSystem()
averagePhase1, rows, cols = computeAveragePhases(
camsys, file1, cx, cy, window) #default window size = 4
ds1 = c / (2 * modFreq1 * 1E6)
phaseActual1 = distance / ds1 * 4096
phaseAverage1 = averagePhase1
phaseCorr = wrapPhaseToSignedInteger(int(phaseAverage1 - phaseActual1))
if file2 and modFreq2:
averagePhase2, rows, cols = computeAveragePhases(
camsys, file2, cx, cy, window)
ds2 = c / (2 * modFreq2 * 1E6)
phaseActual2 = distance / ds2 * 4096
phaseAverage2 = averagePhase2
phaseCorr2 = wrapPhaseToSignedInteger(int(phaseAverage2 -
phaseActual2))
else:
phaseCorr2 = 0
if chipset == 'ti.calculus': #additive phase
phaseCorr = -phaseCorr
phaseCorr2 = -phaseCorr2
return True, phaseCorr, phaseCorr2, 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
def validatePage(self):
createNew = False
if self.calibrationWizard.depthCamera:
if self.profiles.currentIndex() == 0:
createNew = True
profileName = str(self.calibrationWizard.profileName)
if createNew:
print profileName
id = self.depthCamera.addCameraProfile(
profileName, self.depthCamera.getCurrentCameraProfileID())
if id < 0:
QtGui.QMessageBox.critical(
'Failed to create a new profile "' + profileName +
'". See logs for more details.')
return False
self.calibrationWizard.currentProfileID = id
self.calibrationWizard.currentConfiguration = self.depthCamera.configFile.getCameraProfile(
id)
self.calibrationWizard.currentProfileName = profileName
else:
self.calibrationWizard.currentConfiguration = self.calibrationWizard.previousConfiguration
self.calibrationWizard.currentProfileName = self.profileNames[
self.profiles.currentIndex() - 1]
self.calibrationWizard.currentProfileID = self.depthCamera.getCurrentCameraProfileID(
)
return True
else:
if self.profileSelectButtons.checkedId() == 1:
self.calibrationWizard.currentConfiguration = self.calibrationWizard.previousConfiguration
self.calibrationWizard.profileName = self.calibrationWizard.currentConfiguration.getProfileName(
)
else:
self.calibrationWizard.currentConfiguration = Voxel.ConfigurationFile(
)
self.calibrationWizard.currentConfiguration.setParentID(
self.calibrationWizard.previousConfiguration.getID())
self.calibrationWizard.profileName = str(
self.calibrationWizard.profileName)
self.calibrationWizard.currentConfiguration.setProfileName(
(self.calibrationWizard.profileName))
self.calibrationWizard.currentConfiguration.setID(
150) #change this id in the actual conf file
return True
def hdrCommonPhaseOffset(fileName1,
distance,
modFreq1,
cx=0,
cy=0,
fileName2=None,
modFreq2=None,
window=4,
chipset='TintinCDKCamera'):
""" Calculates HDR phase offsets for ti chipsets.
.. note: Make sure that the hdr flag is on for the file before capturing the file"""
c = 299792458. # m/s
camsys = Voxel.CameraSystem()
ret1 = computeHDRAveragePhases(camsys, fileName1, cx, cy, window, chipset)
if not ret1:
return False
ret1, averagePhase1, rows, cols = ret1
ds1 = c / (2 * modFreq1 * 1E6)
phaseActual1 = distance / ds1 * 4096
hdrphaseCorr = wrapPhaseToSignedInteger(int(averagePhase1 - phaseActual1))
if chipset == 'TintinCDKCamera':
if fileName2 and modFreq2:
ret2, averagePhase2, _, _ = computeHDRAveragePhases(
camsys, fileName2, cx, cy, window)
if not ret2:
return True, hdrphaseCorr, 0
ds2 = c / (2 * modFreq2 * 1E6)
phaseActual2 = distance / ds2 * 4096
hdrphaseCorr2 = wrapPhaseToSignedInteger(
int(averagePhase2 - phaseActual2))
else:
hdrphaseCorr2 = 0
elif chipset == 'CalculusCDKCamera':
hdrphaseCorr = -hdrphaseCorr
hdrphaseCorr2 = 0
return True, hdrphaseCorr, hdrphaseCorr2
### point.i is intensity, which come from amplitude
### point.z is distance, which come from depth
# for index in range(pointCloudFrame.size()):
# point = pointCloudFrame.points[index]
# print("current point : index %s [ x : %s , y: %s ,z : %s ,i : %s]" %(index, point.x,point.y,point.z,point.i))
def stop(self):
if self.depthCamera:
self.depthCamera.stop()
self.depthCamera.clearAllCallbacks()
del self.depthCamera
self.depthCamera = None
cameraSystem = Voxel.CameraSystem()
devices = cameraSystem.scan()
if len(devices) == 1:
print(" Find one device.")
window = MainWindow(cameraSystem)
key = raw_input("Input enter key to quit.")
print(" Quit now.")
window.stop()
else:
print(" No device found.")
del cameraSystem
from Hand import *
window.fps_counter.enabled = True
window.exit_button.visible = False
noise = PerlinNoise(octaves=2, seed=round(time.time()))
map_size = 8 * 3
lower_bound = -10
for z in range(map_size):
for x in range(map_size):
y = round(noise([x / map_size, z / map_size]) * 5)
for i in range(lower_bound, y + 1):
voxel = Voxel(type='grass' if i == y else
('dirt' if i > y - 3 else 'stone'),
position=(x - map_size / 2, i, z - map_size / 2))
hand = Hand()
sky = mySky()
player = FirstPersonController()
def update():
if held_keys['escape']:
application.quit()
if held_keys['1']:
param.block_pick = 'stone'
if held_keys['2']:
param.block_pick = 'grass'
if held_keys['3']:
def __init__(self, device):
self.system = Voxel.CameraSystem()
self.resolution = VxlCameraInfo.deviceResolution[device]
self.modFreq2,
chipset=self.depthCamera.chipset())
except Exception, e:
print(e)
ret = False
if ret:
self.paramsText += "phase_corr_1 = %d\n phase_corr_2 = %d\n" % (
phaseCorr1, phaseCorr2)
self.calibrationWizard.calibParams['phase_corr1'] = phaseCorr1
self.calibrationWizard.calibParams['phase_corr2'] = phaseCorr2
else:
QtGui.QMessageBox.critical(self, "Check Data",
"Can't get the coefficients")
if self.perPixelCaptured:
try:
c = Voxel.Configuration()
r, path = c.getLocalConfPath()
ret, phaseOffsetFileName, _, _ = perPixelOffset(
self.perPixelFileName,
pathToSave=path,
profileName=self.calibrationWizard.profileName)
except Exception, e:
ret = False
print e
if ret:
self.paramsText += "phaseOffsetFileName: %s" % (
phaseOffsetFileName)
self.calibrationWizard.calibParams[
'phasecorrection'] = 'file:' + os.path.basename(
phaseOffsetFileName)
else:
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
#!/usr/bin/env python2.7
#
# TI Voxel Lib component.
#
# Copyright (c) 2014 Texas Instruments Inc.
#
import Voxel
sys = Voxel.CameraSystem()
devices = sys.scan()
print devices
print "Got ", len(devices), " devices"
count = 0
count = count + 1
print count
gdepthCamera = None
pcframe = None
gframe = None
def callback(depthCamera, frame, type):
print 'Hello'
print depthCamera
print frame
import Voxel as vox
import LineUtils as lin
import TrackFit as tf
import LSQ3D as lsq3d
points = []
fin = open('Niffte-event.dat')
for line in fin:
data = (line.strip()).split()
volume = int(data[0])
row = int(data[1])
column = int(data[2])
bucket = int(data[3])
adc = int(data[4])
voxel = vox.Voxel(volume,row,column,bucket,adc)
points.append(ngeo.MapVoxeltoXYZ(voxel))
#sort them in order of farthest from the origin (0,0,0) to closest
points.sort(key=attrgetter('mag'),reverse=True)
print "Finding best fit line...\n"
track = lsq3d.LSQ3D(points)
print track
#newe = (track.start).add((track.dir).scale(track.length))
#print newe
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
def predict():
# Load the model
model = get_model()
#model.load("Unet-softmax/model_ACDC")
model.load("Model_StairNet_IVUS")
Images, Filenames = Getnpys()
numImage = len(Images)
#for i in images
for i in range(numImage):
# get a pair of images
img = Images[i]
img = np.expand_dims(img, axis=3)
print(Filenames[i])
print(img.shape)
# Deploy the model on img
y_pred = model.predict(img.astype(np.float32))
y_pred = np.array(y_pred).astype(np.float32)
y_pred[y_pred < 0.5] = 0
#y_pred = np.clip(y_pred, 0, 1)
y_pred = np.argmax(y_pred, axis=3)
shape = y_pred.shape
#print(y_pred.shape)
#y_pred = y_pred.reshape(shape[0], shape[1], shape[2])
# y_pred = np.round(y_pred)
# y_pred = np.clip(y_pred, 0, 1)
# y_pred = np.reshape(y_pred, (-1, 256, 256))
# y_pred = y_pred.astype(np.uint8, copy=False)
print(y_pred.shape)
# Save the prediction
# idx_aorta = y_pred > 0
# y_pred[idx_aorta] = 255
# skimage.io.imsave(SaveDir + Filenames[i] + "_pred.tif", y_pred)
##################################################################################
# Make the overlay
# Convert img from gray to 3 channels image and overlay the mask
# img = np.squeeze(img)
# rgbImg = np.zeros([img.shape[0],256,256,3], dtype=np.uint8)
# rgbImg[:,:,:,0] = img
# rgbImg[:,:,:,1] = img
# rgbImg[:,:,:,2] = img
# rgbImg[idx_aorta,0] = (rgbImg[idx_aorta,0] + 255) / 2
# rgbImg[idx_aorta,1] = rgbImg[idx_aorta,1] / 2
# rgbImg[idx_aorta,2] = rgbImg[idx_aorta,2] / 2
# skimage.io.imsave(SaveDir + Filenames[i] + "_overlay.tif", rgbImg)
np.save(SaveDir + Filenames[i] + "_pred.npy", y_pred)
pVoxel = vx.PyVoxel()
pVoxel.NumpyArraytoVoxel(y_pred)
pVoxel.WriteToBin(SaveDir + Filenames[i] + "_pred.bin")
import matplotlib.pyplot as plt
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()
def flatWallLensCalibration(fileName1, distance1, fileName2, distance2, cx= 0 , cy = 0):
camsys = Voxel.CameraSystem()
nearPhase, _, _ = computeAveragePhases(camsys, fileName1, cx, cy, window= 0)
farPhase, _, _ = computeAveragePhases(camsys, fileName2, cx, cy, window = 0)
deltaPhase = farPhase - nearPhase
deltaPhaseSmooth = snd.uniform_filter (deltaPhase, 5, mode = 'nearest')
# 1. Compute normal pixel
ny, nx = np.unravel_index(np.argmin(deltaPhaseSmooth), deltaPhase.shape)
rows, columns = deltaPhase.shape
# 2. Construct a set of all possible distances from the Normal Pixel
# a is the set of all squared distances from the normal pixel
y = np.outer(np.linspace(0, rows - 1, rows), np.ones((columns,)))
x = np.outer(np.ones((rows,)), np.linspace(0, columns - 1, columns))
a = np.square(y - ny) + np.square(x - nx)
# a1 is the set of all unique distances from the normal pixel
(a1, inverse) = np.unique(a.reshape(-1), return_inverse=True)
# a_root is the matrix of all pixel distances from the normal pixel
a1Root = np.sqrt(a1)
# inverse1 is the matrix with the index in a1 of a pixel's distance from the normal pixel
inverse1 = inverse.reshape(rows, -1)
# 3. For every distance, take the set of pixels at the same distance from the normal pixel
# and take the mean of the corresponding cosThetas at each distance
cosThetas = []
cosThetaMatrix = np.zeros(inverse1.shape)
for index, value in enumerate(a1):
i = inverse1 == index
co = deltaPhaseSmooth[ny, nx]/np.mean(deltaPhaseSmooth[i])
cosThetas.append(co)
cosThetaMatrix[i] = co
cosThetas = np.array(cosThetas)
# This array is now the set of pixel distances vs cosThetas
# We can use this directly to compute per pixel offsets if we like
# Note: there might be some cosThetas > 1. Clamping it for now
cosThetas = np.clip(cosThetas, 0, 1)
cosThetaMatrix = np.clip(cosThetaMatrix, 0, 1)
# 4. Note: before computing tanThetas, we need to translate these to Cx, Cy - see step 4 in the PPT
cosThetas = cosThetas*deltaPhaseSmooth[ny, nx]/deltaPhaseSmooth[cy, cx]
cosThetaMatrix = cosThetaMatrix*deltaPhaseSmooth[ny, nx]/deltaPhaseSmooth[cy, cx]
tanThetas = np.tan(np.arccos(cosThetas))
# 5. Use either scipy.optimize.curve_fit or np.linalg.lstsq to fit the tanTheta function
# x is pixel distance (a1_root)
# and tanThetas is the measured tanTheta
# Note: should we skip a few distances at the beginning?
popt, pcov = sopt.curve_fit(lambda x, f, k1, k2, k3: f*x*(1 + x*x*(k1 + x*x*(k2 + x*x*k3))), tanThetas, a1Root)
#popt[] should now be f, k1, k2, k3
# And can be used for distortion matrix
# p1, p2 are assumed to be 0 (no tangential distortion) and fx, fy are assumed to be equal to f
if popt and pcov:
mtx = np.array([[popt[0], 0, cx], [0, popt[1], cy], [0 ,0 , 1]])
dist = np.array([popt[2], popt[3], 0., 0, popt[3]])
return True, mtx, dist
else:
return False
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()
return averagePhase, rows, cols
if __name__ == "__main__":
camsys = Voxel.CameraSystem()
if len(sys.argv) != 5:
print("Usage: computeAveragePhases.py inFile.vxl cx cy, window")
sys.exit()
inFileName = sys.argv[1]
cx = float(sys.argv[2])
cy = int(sys.argv[3])
window = int(sys.argv[4])
averagePhase, _, _ = computeAveragePhases(camsys, inFileName, cx, cy,
window)
print(averagePhase)
