File: vmtkcenterlineinterpolation.py

package info (click to toggle)
vmtk 1.3%2Bdfsg-2.3
  • links: PTS, VCS
  • area: non-free
  • in suites: buster
  • size: 8,932 kB
  • sloc: cpp: 82,947; ansic: 31,817; python: 21,462; perl: 381; makefile: 93; ruby: 41; sh: 19
file content (125 lines) | stat: -rw-r--r-- 4,467 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#!/usr/bin/env python

## Program:   VMTK
## Module:    $RCSfile: vmtkcenterlineinterpolation.py,v $
## Language:  Python
## Date:      $Date: 2006/07/17 09:52:56 $
## Version:   $Revision: 1.1 $

##   Copyright (c) Luca Antiga, David Steinman. All rights reserved.
##   See LICENCE file for details.

##      This software is distributed WITHOUT ANY WARRANTY; without even 
##      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
##      PURPOSE.  See the above copyright notices for more information.


import vtk
import sys

import pypes

vmtkcenterlineinterpolation = 'vmtkCenterlineInterpolation'

class vmtkCenterlineInterpolation(pypes.pypeScript):

    def __init__(self):

        pypes.pypeScript.__init__(self)
        
        self.Centerlines = None
        self.MaskArrayName = None
        self.Threshold = 0.0
        self.InsideOut = 0

        self.SetScriptName('vmtkcenterlineinterpolation')
        self.SetScriptDoc('smooth centerlines with a moving average filter')
        self.SetInputMembers([
            ['Centerlines','i','vtkPolyData',1,'','the input centerlines','vmtksurfacereader'],
      	    ['MaskArrayName','array','str',1,'','the array used for determining what portion of the centerline has to be reinterpolated is stored'],
            ['Threshold','threshold','float',1,'','value of the mask array below which (above which, in case insideout is 1) the centerline is reinterpolated'],
            ['InsideOut','insideout','bool',1,'','toggle interpolating below (0) or above (1) the threshold value']
            ])
        self.SetOutputMembers([
            ['Centerlines','o','vtkPolyData',1,'','the output centerlines','vmtksurfacewriter']
            ])

    def IsMasked(self, value):
        return (not self.InsideOut and value < self.Threshold) or (self.InsideOut and value > self.Threshold)

    def Execute(self):

        if self.Centerlines == None:
            self.PrintError('Error: No input centerlines.')

        maskArray = self.Centerlines.GetPointData().GetArray(self.MaskArrayName)

        numberOfArrays = self.Centerlines.GetPointData().GetNumberOfArrays()

        for i in range(self.Centerlines.GetNumberOfCells()):

            cell = self.Centerlines.GetCell(i)

            xSpline = vtk.vtkCardinalSpline()
            ySpline = vtk.vtkCardinalSpline()
            zSpline = vtk.vtkCardinalSpline()

            aSplines = []
            for j in range(numberOfArrays):
                aSplines.append(vtk.vtkCardinalSpline())

            abscissaArray = vtk.vtkFloatArray()

            abscissa = 0.0
            previousPoint = None
            for j in range(cell.GetNumberOfPoints()):

                pointId = cell.GetPointId(j)
                point = self.Centerlines.GetPoint(pointId)

                if previousPoint:
                    abscissa += vtk.vtkDistance2BetweenPoints(point,previousPoint)**0.5

                abscissaArray.InsertNextValue(abscissa)

                if not self.IsMasked(maskArray.GetTuple1(pointId)):

                    xSpline.AddPoint(abscissa,point[0])
                    ySpline.AddPoint(abscissa,point[1])
                    zSpline.AddPoint(abscissa,point[2])

                    for k in range(numberOfArrays):
                        array = self.Centerlines.GetPointData().GetArray(k)
                        if array.GetNumberOfComponents() != 1:
                            continue
                        value = array.GetTuple1(pointId)
                        aSplines[k].AddPoint(abscissa,value)

                previousPoint = point

            for j in range(cell.GetNumberOfPoints()):
                
                pointId = cell.GetPointId(j)

                if not self.IsMasked(maskArray.GetTuple1(pointId)):
                    continue

                abscissa = abscissaArray.GetValue(pointId)
  
                point = [xSpline.Evaluate(abscissa), ySpline.Evaluate(abscissa), zSpline.Evaluate(abscissa)]
                self.Centerlines.SetPoint(pointId,point)

                for k in range(numberOfArrays):
                    array = self.Centerlines.GetPointData().GetArray(k)
                    if array.GetNumberOfComponents() != 1:
                        continue
                    value = aSplines[k].Evaluate(abscissa)
                    array.SetTuple1(pointId,value)



if __name__=='__main__':

    main = pypes.pypeMain()
    main.Arguments = sys.argv
    main.Execute()