try: paraview.simpl
except: from paraview.simple import *

import os

from subprocess import *
#in_filename = "c:/Users/.../t3p_results/OUTPUT/signal.out"
in_filename = "./t3p_results/OUTPUT/signal.out"
#print "in_filename: '%s'" % in_filename
print("in_filename:", in_filename)


########################################

def get_data(filename):
  time_fft_out = CSVReader(FileName=filename,
                           FieldDelimiterCharacters = ' ',
                           HaveHeaders = 0)
  time_fft_out.UpdatePipeline()  # this is necessary!  blank objects otherwise...
  return time_fft_out


def show_timeFFT(time_fft_out):
  # Create a new 'Line Chart View'
  lineChartView1 = CreateView('XYChartView')
  lineChartView1.ViewTime=0.0
  lineChartView1.ChartTitle = 'Signal'
  lineChartView1.LeftAxisTitle = 'Signal value'
  lineChartView1.BottomAxisTitle = 't [ns]'
#  XYChartView1 = CreateXYPlotView()
#  XYChartView1.ViewTime=0.0

#  animscene = GetAnimationScene()
#  animscene.ViewModules = [ XYChartView1 ]

  ######################################
  pf1 = ProgrammableFilter(registrationName='ProgrammableFilter1', Input=time_fft_out)
  pf1.OutputDataSetType = 'vtkTable'
  pf1.CopyArrays = 0
  pf1.RequestUpdateExtentScript = ''
  pf1.PythonPath = ''
  pf1.RequestInformationScript = ''
  pf1.Script = \
"""\
import math
import numpy

try:
  import warnings
  warnings.simplefilter("ignore", numpy.ComplexWarning)
except:
  pass

input = self.GetInput()
scale = input.GetRowData().GetArray(1).GetRange()[1] / input.GetRowData().GetArray(2).GetRange()[1]

t1 = input.GetColumn(0)
W1 = input.GetColumn(1) 
I1 = input.GetColumn(2)

n1 = t1.GetNumberOfTuples()

# t
col_t = vtk.vtkDoubleArray()
col_t.SetName("t")
col_t.SetNumberOfTuples(n1)
#col_t.DeepCopy(input.GetColumn(0))
for i in range(n1):
 col_t.SetValue(i, t1.GetValue(i)*1.e9)

# W
col_W = vtk.vtkDoubleArray()
col_W.SetName("V")
col_W.SetNumberOfTuples(n1)
#col_W.DeepCopy(input.GetColumn(1))
for i in range(n1):
  col_W.SetValue(i, W1.GetValue(i))

# I
col_I = vtk.vtkDoubleArray()
col_I.SetName("I")
col_I.SetNumberOfTuples(n1)
#col_I.DeepCopy(input.GetColumn(2))
for i in range(n1):
  col_I.SetValue(i, scale * I1.GetValue(i))

output = self.GetOutputDataObject(0)
output.AddColumn(col_t)
output.AddColumn(col_I)
output.AddColumn(col_W)
"""

  ######################################
  pd1 = PlotData(registrationName='PlotData1', Input=pf1)

  dr1 = GetDisplayProperties(pd1)
  dr1.Visibility = 0
  dr1.UseIndexForXAxis = 0
  dr1.XArrayName = 't'
  dr1.AttributeType = 'Row Data'
  dr1.SeriesVisibility = ['V', 'I']
  dr1.SeriesColor = ['t',                  '0.0', '1.0', '0.0', \
                     'V',                  '1.0', '0.0', '0.0', \
                     'I',                  '0.0', '0.7', '0.0', \
                     'vtkOriginalIndices', '0.0', '0.0', '0.0']
  dr1.SeriesLineStyle = ['I', '2']
  dr1.Visibility = 1

  Show(pd1, lineChartView1, 'XYChartRepresentation')
  return lineChartView1

def show_impedanceplot(time_fft_out):
  # Create a new 'Line Chart View'
  lineChartView2 = CreateView('XYChartView')
  lineChartView2.ChartTitle = 'Signal Spectrum'
  lineChartView2.LeftAxisTitle = 'fft(signal)/fft(source)'
  lineChartView2.BottomAxisTitle = 'f [GHz]'

  pf2 = ProgrammableFilter(registrationName='ProgrammableFilter2', Input=time_fft_out)
  pf2.OutputDataSetType = 'vtkTable'
  pf2.CopyArrays = 0
  pf2.RequestUpdateExtentScript = ''
  pf2.PythonPath = ''
  pf2.RequestInformationScript = ''
  pf2.Script = \
"""\
import math
import numpy

try:
  import warnings
  warnings.simplefilter("ignore", numpy.ComplexWarning)
except:
  pass

input = self.GetInput()

n = input.GetColumn(0).GetNumberOfTuples()
n2 = int(n/100)

t0 = input.GetColumn(0).GetValue(0)
t1 = input.GetColumn(0).GetValue(1)
dt = (t1 - t0)
f_max = 1.0/dt

print("t0:", t0)
print("t1:", t1)
print("dt:", dt)
print("f_max:", f_max)

####################
# get FFTs

temp = []
for i in range(n):
  temp.append(input.GetColumn(1).GetValue(i))
w = numpy.fft.fft(temp)  # FFT(W)

temp = []
for i in range(n):
  temp.append(input.GetColumn(2).GetValue(i))
v = numpy.fft.fft(temp)  # FFT(I)

####################
# figure out where to stop on x axis

I_max = input.GetRowData().GetArray(2).GetRange()[1]
limit = ((math.e)**-3.0) * I_max

for i in range(n2):
  if abs(v[i]) < limit:
    n2 = i
    break

####################
# frequency axis

col_f = vtk.vtkDoubleArray()
col_f.SetName("f")
col_f.SetNumberOfTuples(n2)
for i in range(n2):
  col_f.SetValue(i, (f_max)*(float(i)/n)/1.0e9)

####################
# FFT of W

col_W = vtk.vtkDoubleArray()
col_W.SetName("FFT(W)")
col_W.SetNumberOfTuples(n2)
for i in range(n2):
  col_W.SetValue(i, numpy.sqrt(w[i]*w[i].conjugate()))

####################
# FFT of I

col_I = vtk.vtkDoubleArray()
col_I.SetName("FFT(I)")
col_I.SetNumberOfTuples(n2)
for i in range(n2):
  col_I.SetValue(i, numpy.sqrt(v[i]*v[i].conjugate()))

####################
# impedance

Zmax = 0.
Imax = 0.

col_Z = vtk.vtkDoubleArray()
col_Z.SetName("Z")
col_Z.SetNumberOfTuples(n2)
for i in range(n2):
  W = w[i]
  I = v[i]

  Z = W/I
  Z = numpy.sqrt(Z*Z.conjugate())

  col_Z.SetValue(i, Z)

  if Z > Zmax:
       Zmax = Z
  I = numpy.sqrt(I*I.conjugate())
  if I > Imax:
       Imax = I

scale = Zmax/Imax
col_I1 = vtk.vtkDoubleArray()
col_I1.SetName("I")
col_I1.SetNumberOfTuples(n2)
for i in range(n2):
  I = scale*v[i]
  I = numpy.sqrt(I*I.conjugate())

  col_I1.SetValue(i, I)

####################
# populate the graph

output = self.GetOutputDataObject(0)
output.AddColumn(col_f)
output.AddColumn(col_W)
output.AddColumn(col_I)
output.AddColumn(col_Z)
output.AddColumn(col_I1)
"""
  ######################################
  pd2 = PlotData(registrationName='PlotData2', Input=pf2)

  dr2 = GetDisplayProperties(pd2)
  dr2.Visibility = 0
  dr2.UseIndexForXAxis = 0
  dr2.XArrayName = 'f'
  dr2.AttributeType = 'Row Data'
  dr2.SeriesVisibility = ['Z', 'I']
  dr2.SeriesColor = ['f',                  '0.0', '1.0', '0.0', \
                     'FFT(W)',             '1.0', '0.0', '0.0', \
                     'FFT(I)',             '0.0', '0.7', '0.0', \
                     'Z',                  '0.0', '0.0', '1.0', \
                     'vtkOriginalIndices', '0.0', '0.0', '0.0']
  dr2.SeriesLineStyle = ['I', '2']
  dr2.Visibility = 2
  Show(pd2, lineChartView2, 'XYChartRepresentation')
  return lineChartView2


################################################################################
################################################################################

paraview.simple._DisableFirstRenderCameraReset()

SetActiveView(None)

tmp_filename = in_filename+".tmp"
out_file = open(tmp_filename, 'w')
for l in open(in_filename):
  line = l.strip()
  if not line.startswith('#'):
#    print >>out_file, line.rstrip()
    print (line.rstrip(), file=out_file)
out_file.close()

if tmp_filename == '':
  print("Signal plot cancelled.")
else:
#  print "temporary filename: '%s'" % tmp_filename
  print("temporary filename:", tmp_filename)

time_fft_out = get_data(tmp_filename)
# ----------------------------------------------------------------
# setup view layouts
# ----------------------------------------------------------------
lineChartView1 = show_timeFFT(time_fft_out)
lineChartView2 = show_impedanceplot(time_fft_out)
# create new layout object 'timeFFT'
layout1 = CreateLayout(name='timeFFT')
layout1.SplitVertical(0, 0.500000)
layout1.AssignView(1, lineChartView1)
layout1.AssignView(2, lineChartView2)

# ----------------------------------------------------------------
# restore active view
SetActiveView(lineChartView1)

#os.remove(tmp_filename)
Render()