【Python】曲线简化算法实现

Overview

曲线简化算法通常应用于运动捕捉数据的关键帧提取，在此基础上还演化出了更多的算法

本文对基本的曲线简化算法进行了代码实现，以关键帧个数或线性重建误差作为迭代终止条件

其中，计算点i到直线n1-n2的距离公式如下[1]：



更多算法及分析可参考[2]

Code

注释中提供一些简单的说明以便于理解

#!/usr/bin/env python
#-*- coding: utf-8 -*-

#######################
# Info : Curve Simplify
# Version 1.0
# Author : Alex Pan
# Date : 2017-07-11
#######################

import numpy as np
from termcolor import colored
import ipdb

## Data Type
uintType = np.uint8
floatType = np.float32

##-----------------------------------------------------------------------------------
## Get Distance Between point and [line_start-line_end] Line
def getPoint2LineDistance(point, line_start, line_end):
# Exception
if not isinstance(point, np.ndarray) or not isinstance(line_start, np.ndarray) or not isinstance(line_end, np.ndarray):
raise TypeError('All points MUST be numpy.ndarray!')
elif point.ndim != 1 or point.shape != line_start.shape or point.shape != line_end.shape:
raise ValueError('points dimensions error or NOT matched!')
elif (line_start == line_end).all():
raise Exception('line_start is the SAME as line_end!')

return np.sqrt(np.sum(np.square(point - line_start)) - np.square(np.sum((line_end - line_start) * (point - line_start))) / np.sum(np.square(line_end - line_start), dtype = floatType))

##-----------------------------------------------------------------------------------
## Constrcuct np.linspace Array between raw_array[index_start] and raw_array[index_end]
def getLinspaceArray(raw_array, index_start, index_end):
# Exception
if not isinstance(raw_array, np.ndarray):
raise TypeError('raw_array MUST be numpy.ndarray!')
elif index_start < 0 or index_end > raw_array.shape[0] or index_start > index_end:
raise ValueError('index_start or index_end INVALID!')

# Reconstruct Array by np.linspace Based on keyIndexes
linspaceArray = np.linspace(raw_array[index_start][0], raw_array[index_end][0], num = index_end - index_start + 1, endpoint = True, dtype = floatType)
for i in xrange(1, raw_array.shape[1]):
linspaceArray = np.row_stack((linspaceArray, np.linspace(raw_array[index_start][i], raw_array[index_end][i], num = index_end - index_start + 1, endpoint = True, dtype = floatType)))

return np.transpose(linspaceArray)

##-----------------------------------------------------------------------------------
## Compute Error Between 2 Arrays
def computeReconstructError(array_A, array_B):
# Exception
if not isinstance(array_A, np.ndarray) or not isinstance(array_B, np.ndarray):
raise TypeError('array_A and array_B MUST be numpy.ndarray!')
elif array_A.shape != array_B.shape:
raise ValueError('array_A and array_B dimensions NOT matched!')

# Vector
if array_A.ndim == array_B.ndim == 1:
return np.sqrt(np.sum(np.square(array_A - array_B)))

# Array
error_array = array_A - array_B
error_list = [np.sqrt(np.sum(np.square(error))) for error in error_array]

return float(sum(error_list)) / len(error_list)

##-----------------------------------------------------------------------------------
## Function of Curve Simplify Algorithm
def curveSimplify(poses_array, max_key = 10, error_threshold = 0.05):
# Exception
if not isinstance(poses_array, np.ndarray):
raise TypeError('poses_array MUST be numpy.ndarray!')

# Initialize
N_poses, M_poses = poses_array.shape
keyIndexes = [0, N_poses - 1]
reconstructArray = getLinspaceArray(raw_array = poses_array, index_start = keyIndexes[0], index_end = keyIndexes[-1])

# Divide
flagContinue = True
while flagContinue:
keyIndexes.sort()
keyDeltas = [(keyIndexes[i], keyIndexes[i + 1]) for i in xrange(len(keyIndexes) - 1)]
for keyStart, keyEnd in keyDeltas:
distanceList = [getPoint2LineDistance(point = poses_array[i], line_start = poses_array[keyStart], line_end = poses_array[keyEnd]) for i in xrange(keyStart + 1, keyEnd)]
keyNew = keyStart + distanceList.index(max(distanceList)) + 1
keyIndexes.append(keyNew)

# Reconstruct [keyStart-keyNew] & [keyNew-keyEnd]
reconstructArray[keyStart : keyNew + 1] = getLinspaceArray(raw_array = poses_array, index_start = keyStart, index_end = keyNew)
reconstructArray[keyNew : keyEnd + 1] = getLinspaceArray(raw_array = poses_array, index_start = keyNew, index_end = keyEnd)
reconstructError = computeReconstructError(poses_array, reconstructArray)

# Print Screen
print colored('keyNum:', 'magenta'), len(keyIndexes)
print 'recError:', colored(str(reconstructError), 'white')

# ipdb.set_trace()

# End Condition: KeyNum or ReconstructError
if len(keyIndexes) == max_key or reconstructError < error_threshold:
flagContinue = False
break

keyIndexes.sort()
return keyIndexes, reconstructError

Reference

[1] 杨涛,肖俊,吴飞,庄越挺. 基于分层曲线简化的运动捕获数据关键帧提取

[2] 杨涛. 人体运动捕获数据关键帧提取算法研究