Example #1
0
def DisplayPcs(scanApath, scanBpath, q, t, plotCosies, stopToDisplay,
               displayNormals):
    from js.data.plyParse import PlyParse
    from js.utils.plot.colors import colorScheme
    from js.geometry.rotations import plotCosy
    import mayavi.mlab as mlab
    colors = colorScheme("label")
    print "parsing", scanApath
    plyA = PlyParse()
    plyA.parse(scanApath)
    pcA = plyA.getPc()
    nA = plyA.getNormals()
    print "parsing", scanBpath
    plyB = PlyParse()
    plyB.parse(scanBpath)
    pcB = plyB.getPc()
    nB = plyB.getNormals()

    R = q.toRot().R

    figm = mlab.figure(bgcolor=(1, 1, 1))
    mlab.points3d(pcA[:, 0],
                  pcA[:, 1],
                  pcA[:, 2],
                  mode="point",
                  color=colors[0])
    #  if plotCosies:
    #    plotCosy(figm, np.eye(3), np.zeros(3), 0.5)
    #    plotCosy(figm, R.T, -R.T.dot(t), 0.5)

    R = R.T
    t = -R.dot(t)
    pcB = (1.001 * R.dot(pcB.T)).T + t
    nB = (1.001 * R.dot(nB.T)).T

    mlab.points3d(pcB[:, 0],
                  pcB[:, 1],
                  pcB[:, 2],
                  mode="point",
                  color=colors[1])

    if displayNormals:
        figm = mlab.figure(bgcolor=(1, 1, 1))
        mlab.points3d(nA[:, 0],
                      nA[:, 1],
                      nA[:, 2],
                      mode="point",
                      color=colors[0])
        mlab.points3d(nB[:, 0],
                      nB[:, 1],
                      nB[:, 2],
                      mode="point",
                      color=colors[1])

    if stopToDisplay:
        mlab.show(stop=True)
def DisplayPcs(scanApath, scanBpath, q,t, plotCosies, stopToDisplay,
    displayNormals):
  from js.data.plyParse import PlyParse
  from js.utils.plot.colors import colorScheme
  from js.geometry.rotations import plotCosy
  import mayavi.mlab as mlab
  colors = colorScheme("label")
  print "parsing", scanApath
  plyA = PlyParse();
  plyA.parse(scanApath)
  pcA = plyA.getPc()
  nA = plyA.getNormals()
  print "parsing", scanBpath
  plyB = PlyParse();
  plyB.parse(scanBpath)
  pcB = plyB.getPc()
  nB = plyB.getNormals()

  R = q.toRot().R

  figm = mlab.figure(bgcolor=(1,1,1))
  mlab.points3d(pcA[:,0], pcA[:,1], pcA[:,2], mode="point",
      color=colors[0])
#  if plotCosies:
#    plotCosy(figm, np.eye(3), np.zeros(3), 0.5)
#    plotCosy(figm, R.T, -R.T.dot(t), 0.5)

  R = R.T
  t = -R.dot(t)
  pcB = (1.001*R.dot(pcB.T)).T + t
  nB = (1.001*R.dot(nB.T)).T

  mlab.points3d(pcB[:,0], pcB[:,1], pcB[:,2], mode="point",
        color=colors[1])

  if displayNormals:
    figm = mlab.figure(bgcolor=(1,1,1))
    mlab.points3d(nA[:,0], nA[:,1], nA[:,2], mode="point",
        color=colors[0])
    mlab.points3d(nB[:,0], nB[:,1], nB[:,2], mode="point",
          color=colors[1])

  if stopToDisplay:
    mlab.show(stop=True)
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np

from js.utils.plot.colors import colorScheme

c1 = colorScheme("labelMap")["turquoise"]
c2 = colorScheme("labelMap")["orange"]

#paper
mpl.rc('font',size=30) 
mpl.rc('lines',linewidth=3.)
figSize = (14, 5.5)
figSize = (14, 10)
figSize = (14, 12)

def ToRad(deg):
  return deg*np.pi/180.
def ToDeg(rad):
  return rad/np.pi*180.

eta0 = ToRad(72.)
eta = ToRad(np.exp(np.linspace(np.log(0.001), np.log(180.),1000)))

a = np.cos(eta0)
b = np.cos(eta*0.5)

N = np.ceil(np.log((1./a - 1.)/(1./b - 1.))/np.log(2.))
N[N<0.] = 0.

fig = plt.figure(figsize = figSize, dpi = 80, facecolor="w",
Example #4
0
import numpy as np
import re
import matplotlib as mpl
import matplotlib.pyplot as plt
from js.utils.plot.colors import colorScheme

mpl.rc('font',size=35) 
mpl.rc('lines',linewidth=4.)
figSize = (14, 5.5)
figSize = (9, 12)
figSize = [(15.4, 10),  (15.4, 10), (15.4, 10), (12.6, 10)]

c1 = colorScheme("labelMap")["turquoise"]
c2 = colorScheme("labelMap")["orange"]
cs = [colorScheme("labelMap")["turquoise"],
    colorScheme("labelMap")["orange"],
    colorScheme("labelMap")["green"] ]

space = ["$Tp\mathbb{S}^{3}$", "AA", "$\mathbb{S}^{3}$", "$\mathbb{R}^3$"]
#space = ["$Tp\mathbb{S}^{3}$", "$\mathbb{S}^{3}$", "$\mathbb{R}^3$"]
disp = [1,1,1,0.7]

# volume of half of the sphere S^3 in 4D
VS3 = np.pi**2 

for i, path in enumerate(['./bb_iteration_stats_TpS3.csv', './bb_iteration_stats_AA.csv',
  './bb_iteration_stats_S3.csv', './bb_iteration_stats_R3.csv']):
  s = np.loadtxt(path).T
  s[:2,:] = np.log(s[:2,:])/np.log(10)
  Y = np.floor(s.shape[1]*disp[i])
values = {
    'DPvMFmeans': Sils[:, 0:paramBase['DPvMFmeans'].size].T,
    'spkm': Sils[:, paramBase['DPvMFmeans'].size::].T
}
fig = plotOverParams(values,
                     'silhouette',
                     paramBase,
                     paramName,
                     baseMap,
                     cfg['base'],
                     showLeg=True,
                     Ns=None)
plt.savefig(cfg['outName'] + '_{}.pdf'.format(re.sub('\$', '', "silhouette")),
            figure=fig)

colA = colorScheme('labelMap')['orange']
colB = colorScheme('labelMap')['turquoise']
idMax = np.argmax(np.mean(values['DPvMFmeans'], axis=1))

fig = plt.figure(figsize=figSize, dpi=80, facecolor='w', edgecolor='k')
# histogram over the number of clusters for all frames
plt.hist(Ks[:, idMax],
         bins=np.arange(0, Ks[:, idMax].max() + 1) + .5,
         alpha=0.7,
         color=colB)
plt.xlim(2, Ks[:, idMax].max() + 1)
#plt.plot(paramBase[base],vMeasures[base][:],label=baseMap[base],c=cl[(i+1)*255/I])
#plt.title("histogram over the number of clusters")
plt.xlabel('number of clusters')
plt.legend(loc='best')
plt.tight_layout()
Example #6
0
  plt.show()
elif D==3:
  figm = mlab.figure(bgcolor=(1,1,1))
  counts = np.bincount(z[-1,:])
  print counts
  if counts.sum() > 30000:
    mode = 'point'
  else:
    mode = 'sphere'
  K = 2*((int(np.max(z[-1,:]))+1)/2)
  M = Sphere(3)
  M.plot(figm,1.)
  if cfg['base'] == 'NiwSphereUnifNoise':
    for k in range(K-1):
      if (z[-1,:]==k).sum() >0:
        mlab.points3d(x[0,z[-1,:]==k],x[1,z[-1,:]==k],x[2,z[-1,:]==k],color=colorScheme('label')[k%7],figure=figm,scale_factor=0.03,mode=mode)
        mu = karcherMeanSphere_propper(np.array([0.,0.,1.]),x[:,z[-1,:]==k]) 
#        print mu
#        mlab.plot3d([0.0,mu[0]],[0.0,mu[1]],[0.0,mu[2]],figure=figm,color=colorScheme('label')[k%7])
        xT = M.LogTo2D(mu,x[:,z[-1,:]==k])
        M.plotCov(figm,np.cov(xT),mu)
    k=K-1
    if (z[-1,:]==k).sum() >0:
      mlab.points3d(x[0,z[-1,:]==k],x[1,z[-1,:]==k],x[2,z[-1,:]==k],color=(0.4,0.4,0.4),figure=figm,scale_factor=0.05,mode=mode)
  elif cfg['base'] in ['DpNiw','DpNiwSphere','DpNiwSphereFull','DpNiwTangent']:
    t =0
    means = np.loadtxt(outName+'.lbl_means.csv')
    covs = np.loadtxt(outName+'.lbl_covs.csv')
    dd = D-1
    while True:
      print "-------- @t={} --------------".format(t)
Example #7
0
import numpy as np
import os.path
import json, re, argparse, sys
import matplotlib as mpl
import matplotlib.pyplot as plt
from js.utils.plot.colors import colorScheme

mpl.rc('font',size=30) 
mpl.rc('lines',linewidth=3.)
figSize = (14, 5.5)
figSize = (14, 10)
figSize = (12, 8)
figSize = (20, 8)
c1 = colorScheme("labelMap")["turquoise"]
c2 = colorScheme("labelMap")["orange"]
c3 = colorScheme("labelMap")["red"]

parser = argparse.ArgumentParser(description = 'plot results from results.json files generated by randomRenderAndCompare.py')
parser.add_argument('-i','--input',
    default="../optRotTrans/", help='path to results folder')
cmdArgs = parser.parse_args()

name = "[a-z_0-9]+_[0-9]+_results.json"

results = []
for root, dirs, files in os.walk(cmdArgs.input):
  for f in files:
    if re.search(name, f):    
      results.append(os.path.join(root,f))
  break # don recurse into subfolders
Example #8
0
 counts = np.bincount(z[-1,:])
 print counts
 if counts.sum() > 3000:
   mode = 'point'
 else:
   mode = 'sphere'
 t =0
 while True:
   print "-------- @t={} --------------".format(t)
   mlab.clf(figm)
   K = 2*((int(np.max(z[t,:]))+1)/2)
   zAll = np.floor(z[t,:]/2)
   print np.bincount(z[t,:])
   for k in range(K/2):
     if (zAll==k).sum() >1:
       mlab.points3d(x[0,z[t,:]==2*k],x[1,z[t,:]==2*k],x[2,z[t,:]==2*k],color=colorScheme('label')[k%7],figure=figm,scale_factor=0.05,mode='2dcross')
       mlab.points3d(x[0,z[t,:]==2*k+1],x[1,z[t,:]==2*k+1],x[2,z[t,:]==2*k+1],color=colorScheme('label')[k%7],figure=figm,scale_factor=0.03,mode='2dcircle')
   key = raw_input("press j,l, <space>:")
   if key =='j':
     t-=1
   elif key == 'l':
     t+=1
   elif key == 'E':
     t=T-1
   elif key == 'q':
     break
   elif key == ' ':
     mlab.show(stop=True)
   else:
     t+=1
   t=t%T
Example #9
0
y = np.cos(u)

mu = np.ones(2)/np.sqrt(2.0)
tau = np.array([0.1, 1.0, 10.0, 100.0])

d = mu[0]*x+mu[1]*y

ed = tau[:, np.newaxis]/(4.0*np.pi*spec.iv(0, tau[:, np.newaxis]))*np.exp(tau[:, np.newaxis]*d)
edmax = tau[:, np.newaxis]/(4.0*np.pi*spec.iv(0, tau[:, np.newaxis]))*np.exp(tau[:, np.newaxis])

for i in range(0, ed.shape[0]):
    fig = plt.figure(facecolor='white')
    ax = plt.axes(frameon=False)

    plt.plot(x, y, color='k', lw=5)
    plt.plot((1.0+ed[i, :]/edmax[i])*x, (1.0+ed[i, :]/edmax[i])*y, color=colorScheme('labelMap')['turquoise'], lw=5)
    for j in range(0, x.shape[0], 10):
        plt.plot(np.array([x[j], (1.0+ed[i, j]/edmax[i])*x[j]]), np.array([y[j], (1.0+ed[i, j]/edmax[i])*y[j]]), lw=1., color=colorScheme('labelMap')['turquoise'])
#    samps = sampleVMF(mu, tau[i], 50)
#    plt.scatter(samps[0, :], samps[1, :], c=colorScheme('labelMap')['orange'], s=200)
    plt.quiver(0, 0,  1.0/np.sqrt(2), 1.0/np.sqrt(2), lw=1, color='k', angles='xy', scale_units='xy', scale=1.0)
    plt.ylim([-2.0, 2.0])
    plt.xlim([-2.0, 2.0])
    ax.axes.get_yaxis().set_visible(False)
    ax.axes.get_xaxis().set_visible(False)
    ax.axes.set_aspect('equal', 'datalim')
    plt.savefig('vmf' + str(i) +'.pdf')

plt.show()

#u = np.linspace(0, 2*np.pi, 100)
Example #10
0
        #    plt.show()
        #    figm2 = rgbd.showWeightedNormals(algo=algo)
        #    fig = rgbd.showAxialSigma()
        #    fig = rgbd.showLateralSigma(theta=30.0)
        #fig = rgbd.bilateralDepthFiltering(theta=30.0)
        #    figm0 = rgbd.showPc(showNormals=True,algo=algo)
        #    figm1 = rgbd.showNormals()

        # show raw normals
        figm1 = mlab.figure(bgcolor=(1, 1, 1))
        M = Sphere(2)
        M.plotFanzy(figm1, 1.0)
        from js.utils.plot.colors import colorScheme
        rgbd.n[2, :] *= -1.
        figm1 = rgbd.showNormals(figm=figm1,
                                 color=colorScheme("labelMap")["orange"])
        # show clustered normals
        figm3 = mlab.figure(bgcolor=(1, 1, 1))
        M = Sphere(2)
        M.plotFanzy(figm1, 1.0)
        mlab.points3d(n[0, :],
                      n[1, :],
                      n[2, :],
                      -z[-1, :],
                      colormap='jet',
                      mode='point')
        #    for k in range(K):
        #      ids = z[-1,:]==k
        #      if np.count_nonzero(ids) > 0:
        #        mlab.points3d(n[0,ids],n[1,ids],n[2,ids],color=((float(k)/K),0,0),
        #            mode='point')
import numpy as np
import os.path
import json, re, argparse, sys
import matplotlib as mpl
import matplotlib.pyplot as plt
from js.utils.plot.colors import colorScheme

mpl.rc('font', size=30)
mpl.rc('lines', linewidth=3.)
figSize = (14, 5.5)
figSize = (12, 8)
figSize = (20, 8)
figSize = (14, 10)
c1 = colorScheme("labelMap")["turquoise"]
c2 = colorScheme("labelMap")["orange"]
c3 = colorScheme("labelMap")["red"]
colors = colorScheme("label")

parser = argparse.ArgumentParser(
    description=
    'plot results from results.json files generated by randomRenderAndCompare.py'
)
parser.add_argument(
    '-i',
    '--input',
    default="/data/vision/fisher/expres1/jstraub/optRotTransCVPR2017_bunny/",
    help='path to results folder')
#    default="/media/jstraub/research/dpOptTrans/", help='path to results folder')
#    default="/home/jstraub/CloudStation/research/dpOptTrans/", help='path to results folder')
#    default="../optRotTrans/", help='path to results folder')
cmdArgs = parser.parse_args()
Example #12
0
def plotOverParamsYaxes(values,name,paramBase,paramName,baseMap,Ns=None,showLeg=None):
  colA = colorScheme('labelMap')['orange']
  colB = colorScheme('labelMap')['turquoise']

  fig = plt.figure(figsize=figSize, dpi=80, facecolor='w', edgecolor='k')
  ax1 = plt.subplot(111)
  base = 'spkm'
  valMean = values[base].mean(axis=1)
  valStd = values[base].std(axis=1)
#  print name,base,valMean
#  print name,base,valStd
  leg1 = ax1.plot(valMean,paramBase[base],label=baseMap[base],c=colA)
  ax1.plot(valMean-valStd,paramBase[base],'--',label=baseMap[base],c=colA,lw=2,alpha=0.7)
  ax1.plot(valMean+valStd,paramBase[base],'--',label=baseMap[base],c=colA,lw=2,alpha=0.7)
  ax1.fill_betweenx(paramBase[base],valMean-valStd , valMean+valStd, color=colA, alpha=0.3)
  if name == '$K$':
    leg1 += ax1.plot([30]*len(paramBase[base]), paramBase[base], '--', label="$K_{T} = 30$", c=colorScheme('labelMap')['red'])
  ax1.set_ylabel(paramName[base],color=colA)  
  ax1.set_ylim(paramBase[base].min(),paramBase[base].max())
  ax1.invert_yaxis()
  for  tl in ax1.get_yticklabels():
    tl.set_color(colA)
  tiks = ax1.get_yticks()
  tikLbl = [str(tik) for tik in tiks[:-1]] 
  tikLbl += [''] 
  ax1.set_yticklabels(tikLbl)
#  ax1.legend(loc='best')
  ax1.set_xlabel(name)  
  if False and name == 'NMI':
    tiks = ax1.get_xticks()
    tikLbl = []
    for tik in tiks[::2]:
      tikLbl += [str(tik),'']
    del tikLbl[-1]
    ax1.set_xticklabels(tikLbl)

  ax2 = ax1.twinx()
  base = 'DPvMFmeans'
  valMean = values[base].mean(axis=1)
  valStd = values[base].std(axis=1)
#  print name,base,valMean
#  print name,base,valStd
  leg2 = ax2.plot(values[base].mean(axis=1),paramBase[base],label=baseMap[base],c=colB)
  ax2.plot(valMean-valStd,paramBase[base],'--',label=baseMap[base],c=colB,lw=2,alpha=0.7)
  ax2.plot(valMean+valStd,paramBase[base],'--',label=baseMap[base],c=colB,lw=2,alpha=0.7)
  ax2.fill_betweenx(paramBase[base],valMean-valStd , valMean+valStd, color=colB, alpha=0.3)
  if not Ns is None: # and not name == '$K$':
    xlim = ax2.get_xlim()
    # first to spkm
    base = 'spkm'
    Nmean = Ns[base].mean(axis=1)
#    iKtrue = np.where(np.abs(Nmean-30)<2)
#    ax1.plot(values[base].mean(axis=1)[iKtrue],paramBase[base][iKtrue],'x',mew=4,ms=15,label=baseMap[base]+' $K={}$'.format(Nmean[iKtrue]),c=colorScheme('labelMap')['red'])
    iKtrue = np.argmin(np.abs(Nmean-30))
    ax1.plot([xlim[0],values[base].mean(axis=1)[iKtrue]], [paramBase[base][iKtrue], paramBase[base][iKtrue]],'-',mew=4,ms=15,label=baseMap[base]+' \
        $K={}$'.format(Nmean[iKtrue]),c=colA, alpha=0.7)
    ax1.plot([xlim[0],values[base].mean(axis=1)[iKtrue]], [paramBase[base][iKtrue], paramBase[base][iKtrue]],'--',mew=4,ms=15,label=baseMap[base]+' \
        $K={}$'.format(Nmean[iKtrue]),c=colorScheme('labelMap')['red'], alpha=1.)
    # then do DPvMFmeans
    base = 'DPvMFmeans'
    Nmean = Ns[base].mean(axis=1)
#    iKtrue = np.where(np.abs(Nmean-30)<2)
#    ax2.plot(values[base].mean(axis=1)[iKtrue],paramBase[base][iKtrue],'x',mew=4,ms=15,label=baseMap[base]+' $K={}$'.format(Nmean[iKtrue]),c=colorScheme('labelMap')['red'])
    iKtrue = np.argmin(np.abs(Nmean-30))
    ax2.plot([values[base].mean(axis=1)[iKtrue],xlim[1]], [paramBase[base][iKtrue], paramBase[base][iKtrue]],'-',mew=4,ms=15,label=baseMap[base]+' \
        $K={}$'.format(Nmean[iKtrue]),c=colB, alpha = 0.7)
    ax2.plot([values[base].mean(axis=1)[iKtrue],xlim[1]], [paramBase[base][iKtrue], paramBase[base][iKtrue]],'--',mew=4,ms=15,label=baseMap[base]+' \
        $K={}$'.format(Nmean[iKtrue]),c=colorScheme('labelMap')['red'], alpha = 1.)
    ax1.set_xlim(xlim)
    ax2.set_xlim(xlim)
  ax2.set_ylabel(paramName[base],color=colB)  
  for  tl in ax2.get_yticklabels():
    tl.set_color(colB)
  tiks = ax2.get_yticks()
  tikLbl = ax2.get_yticklabels()
  tikLbl = [''] 
  tikLbl += [str(tik) for tik in tiks[1:]] 
  ax2.set_yticklabels(tikLbl)
  ax2.set_ylim(paramBase[base].min(),paramBase[base].max())
  if False and name == 'NMI':
    tiks = ax2.get_xticks()
    tikLbl = []
    for tik in tiks[::2]:
      tikLbl += [str(tik),'']
    del tikLbl[-1]
    ax2.set_xticklabels(tikLbl)
  if not showLeg is None and showLeg:
    legs = leg2+leg1
    labs = [leg.get_label() for leg in legs]
    ax2.legend(legs,labs,loc='best',prop={'size':legendSize})
  plt.tight_layout()
  plt.subplots_adjust(right=0.85,bottom=0.3)
  return fig
Example #13
0
def plotOverParams(values,name,paramBase,paramName,baseMap,bases ,Ns=None,showLeg=None):
  colA = colorScheme('labelMap')['orange']
  colB = colorScheme('labelMap')['turquoise']

  fig = plt.figure(figsize=figSize, dpi=80, facecolor='w', edgecolor='k')
  ax1 = plt.subplot(111)
  leg1 = []
  for base in bases:
    if base == 'spkm':
      valMean = values[base].mean(axis=1)
      valStd = values[base].std(axis=1)
    #  print name,base,valMean
    #  print name,base,valStd
      leg1 = ax1.plot(paramBase[base],valMean,label=baseMap[base],c=colA)
      ax1.plot(paramBase[base],valMean-valStd,'--',label=baseMap[base],c=colA,lw=2,alpha=0.7)
      ax1.plot(paramBase[base],valMean+valStd,'--',label=baseMap[base],c=colA,lw=2,alpha=0.7)
      ax1.fill_between(paramBase[base],valMean-valStd , valMean+valStd, color=colA, alpha=0.3)
      if name == '$K$':
        leg1 += ax1.plot( paramBase[base],[30]*len(paramBase[base]), '--', label="$K_{T} = 30$", c=colorScheme('labelMap')['red'])
      ax1.set_xlabel(paramName[base],color=colA)  
      ax1.xaxis.set_label_coords(0.5,-0.08)  
      ax1.set_xlim(paramBase[base].min(),paramBase[base].max())
      ax1.invert_xaxis()
      for  tl in ax1.get_xticklabels():
        tl.set_color(colA)
      tiks = ax1.get_xticks()
      tikLbl = ["{}".format(int(tik)) for tik in tiks[:-1]] + [''] 
      ax1.set_xticklabels(tikLbl)
    #  ax1.legend(loc='best')
      ax1.set_ylabel(name)  
      if False and name == 'NMI':
        tiks = ax1.get_yticks()
        tikLbl = []
        for tik in tiks[::2]:
          tikLbl += [str(tik),'']
        del tikLbl[-1]
        ax1.set_yticklabels(tikLbl)
    elif base == 'DPvMFmeans':
      ax2 = ax1.twiny()
      valMean = values[base].mean(axis=1)
      valStd = values[base].std(axis=1)
    #  print name,base,valMean
    #  print name,base,valStd
      leg2 = ax2.plot(paramBase[base],values[base].mean(axis=1),label=baseMap[base],c=colB)
      ax2.plot(paramBase[base],valMean-valStd,'--',label=baseMap[base],c=colB,lw=2,alpha=0.7)
      ax2.plot(paramBase[base],valMean+valStd,'--',label=baseMap[base],c=colB,lw=2,alpha=0.7)
      ax2.fill_between(paramBase[base],valMean-valStd , valMean+valStd, color=colB, alpha=0.3)
      ax2.set_xlabel(paramName[base],color=colB)  
      ax2.xaxis.set_label_coords(0.5,1.12)  
      for  tl in ax2.get_xticklabels():
        tl.set_color(colB)
      tiks = ax2.get_xticks()
      tikLbl = ax2.get_xticklabels()
      tikLbl = [''] + [str(int(tik)) for tik in tiks[1:]] 
      ax2.set_xticklabels(tikLbl)
      ax2.set_xlim(paramBase[base].min(),paramBase[base].max())
      if False and name == 'NMI':
        tiks = ax2.get_yticks()
        tikLbl = []
        for tik in tiks[::2]:
          tikLbl += [str(tik),'']
        del tikLbl[-1]
        ax2.set_yticklabels(tikLbl)
      if not showLeg is None and showLeg:
        legs = leg2+leg1
        labs = [leg.get_label() for leg in legs]
        ax2.legend(legs,labs,loc='best',prop={'size':legendSize})
      plt.tight_layout()
      plt.subplots_adjust(right=0.85,bottom=0.3)
  return fig
Example #14
0
#    plt.show()
#    figm2 = rgbd.showWeightedNormals(algo=algo)
#    fig = rgbd.showAxialSigma()
#    fig = rgbd.showLateralSigma(theta=30.0)
    #fig = rgbd.bilateralDepthFiltering(theta=30.0)
#    figm0 = rgbd.showPc(showNormals=True,algo=algo)
#    figm1 = rgbd.showNormals()


    # show raw normals
    figm1 = mlab.figure(bgcolor=(1,1,1))
    M = Sphere(2)
    M.plotFanzy(figm1,1.0) 
    from js.utils.plot.colors import colorScheme
    rgbd.n[2,:] *= -1.
    figm1=rgbd.showNormals(figm=figm1,color=colorScheme("labelMap")["orange"])
    # show clustered normals
    figm3 = mlab.figure(bgcolor=(1,1,1))
    M = Sphere(2)
    M.plotFanzy(figm1,1.0) 
    mlab.points3d(n[0,:],n[1,:],n[2,:],-z[-1,:],colormap='jet',
            mode='point')
#    for k in range(K):
#      ids = z[-1,:]==k
#      if np.count_nonzero(ids) > 0:
#        mlab.points3d(n[0,ids],n[1,ids],n[2,ids],color=((float(k)/K),0,0),
#            mode='point')
    mlab.show(stop=True)
  elif  'multiFromFile' in mode and 'disp' in mode:
    figm0 = rgbd.showPc(figm=figm0,showNormals=True,algo=algo)
    figm1 = rgbd.showNormals(figm=figm1)
Example #15
0
            if re.search(pattern, f):
                scans.append(os.path.join(root, f))
    scans = sorted(
        scans,
        key=lambda f: int(
            re.sub(".ply", "", re.sub("frame_", "",
                                      os.path.split(f)[1]))))
    #  scans = scans[:4]
    print scans
    #  scans = [
    #      os.path.abspath('../data/stairs/HokuyoPcNormals_1.ply'),
    #      os.path.abspath('../data/stairs/HokuyoPcNormals_2.ply')]
    gt = []

print scans
colors = colorScheme("label")

if showUntransformed or showTransformed:
    import mayavi.mlab as mlab

#figm = mlab.figure(bgcolor=(1,1,1))
#ply = PlyParse();
#ply.parse(scans[0])
#pc = ply.getPc()
#rgb = ply.rgb
#PlotShadedColoredPc(pc, rgb, np.array([255,0,0]),0.6)
#mlab.show(stop=True)

if showUntransformed:
    figm = mlab.figure(bgcolor=(1, 1, 1))
    for i in range(len(scans)):
print 'mean',np.mean(Ks,axis=0)
print 'std',np.std(Ks,axis=0)
print ' --------------------------------'

print cfg['base'] 
paramBase['DPvMFmeans'] = np.arccos(paramBase['DPvMFmeans'] + 1.)*180./np.pi
# mean number of clusters
values = {'DPvMFmeans': Ks[:,0:paramBase['DPvMFmeans'].size].T, 'spkm': Ks[:,paramBase['DPvMFmeans'].size::].T}
fig = plotOverParams(values,'K',paramBase,paramName,baseMap,cfg['base'] ,showLeg=True,Ns=None)
plt.savefig(cfg['outName']+'_{}.pdf'.format(re.sub('\$','',"K")),figure=fig)
# silhouette plot
values = {'DPvMFmeans': Sils[:,0:paramBase['DPvMFmeans'].size].T, 'spkm': Sils[:,paramBase['DPvMFmeans'].size::].T}
fig = plotOverParams(values,'silhouette',paramBase,paramName,baseMap,cfg['base'] ,showLeg=True,Ns=None)
plt.savefig(cfg['outName']+'_{}.pdf'.format(re.sub('\$','',"silhouette")),figure=fig)

colA = colorScheme('labelMap')['orange']
colB = colorScheme('labelMap')['turquoise']
idMax = np.argmax(np.mean(values['DPvMFmeans'],axis=1))

fig = plt.figure(figsize=figSize, dpi=80, facecolor='w', edgecolor='k')
# histogram over the number of clusters for all frames
plt.hist(Ks[:,idMax],bins=np.arange(0,Ks[:,idMax].max()+1)+.5, alpha =0.7,color=colB)
plt.xlim(2,Ks[:,idMax].max()+1)
#plt.plot(paramBase[base],vMeasures[base][:],label=baseMap[base],c=cl[(i+1)*255/I])
#plt.title("histogram over the number of clusters")
plt.xlabel('number of clusters')
plt.legend(loc='best')
plt.tight_layout()
plt.subplots_adjust(right=0.5,bottom=0.3)
plt.savefig(cfg['outName']+'_histNClusters.pdf',figure=fig)
import numpy as np
import re
import matplotlib as mpl
import matplotlib.pyplot as plt
from js.utils.plot.colors import colorScheme

mpl.rc('font',size=35) 
mpl.rc('lines',linewidth=4.)
figSize = (14, 5.5)
figSize = (9, 12)
figSize = [(15.4, 10),  (15.4, 10), (15.4, 10), (12.6, 10)]

c1 = colorScheme("labelMap")["turquoise"]
c2 = colorScheme("labelMap")["orange"]
cs = [colorScheme("labelMap")["turquoise"],
    colorScheme("labelMap")["orange"],
    colorScheme("labelMap")["green"] ]


space = ["$Tp\mathbb{S}^{3}$", "AA", "$\mathbb{S}^{3}$", "$\mathbb{R}^3$"]
#space = ["$Tp\mathbb{S}^{3}$", "$\mathbb{S}^{3}$", "$\mathbb{R}^3$"]
disp = [1,1,1,0.7]

# volume of half of the sphere S^3 in 4D
VS3 = np.pi**2 

for i, path in enumerate(['./bb_iteration_stats_TpS3.csv', './bb_iteration_stats_AA.csv',
  './bb_iteration_stats_S3.csv', './bb_iteration_stats_R3.csv']):
  s = np.loadtxt(path).T
  s[:2,:] = np.log(s[:2,:])/np.log(10)
  Y = np.floor(s.shape[1]*disp[i])
import numpy as np
from scipy.linalg import solve, eig
import mayavi.mlab as mlab
from project4d import *
from helpers import *
from js.geometry.rotations import *
from js.data.plyParse import PlyParse
from js.utils.plot.colors import colorScheme

colors = colorScheme("label")

q_star = np.array([0.707107, 0.381209, -0.0583624, 0.592683])
cfgBunnyZipper = {"name":"bun_zipper", "lambdaS3": [60], "lambdaR3": 0.001}
cfg = cfgBunnyZipper
if cfg["name"] == "bun_zipper":
  scans = ['../data/bunny_rnd/bun_zipper.ply',
      '../data/bunny_rnd/bun_zipper_angle_90_translation_0.3.ply']
  gt = ['../data/bunny_rnd/bun_zipper_angle_90_translation_0.3.ply_TrueTransformation_angle_90_translation_0.3.csv']

scanApath = scans[0]
scanBpath = scans[1]
nameA = os.path.splitext(os.path.split(scanApath)[1])[0]
nameB = os.path.splitext(os.path.split(scanBpath)[1])[0]

plyA = PlyParse(); plyA.parse(scanApath); pcA = plyA.getPc()
plyB = PlyParse(); plyB.parse(scanBpath); pcB = plyB.getPc()

pcA -= pcA.mean(axis=0)
pcB -= pcB.mean(axis=0)

ranges = [-np.abs(pcA[:,0]).max(), np.abs(pcA[:,0]).max(),
Example #19
0
def plotOverParamsYaxes(values,
                        name,
                        paramBase,
                        paramName,
                        baseMap,
                        Ns=None,
                        showLeg=None):
    colA = colorScheme('labelMap')['orange']
    colB = colorScheme('labelMap')['turquoise']

    fig = plt.figure(figsize=figSize, dpi=80, facecolor='w', edgecolor='k')
    ax1 = plt.subplot(111)
    base = 'spkm'
    valMean = values[base].mean(axis=1)
    valStd = values[base].std(axis=1)
    #  print name,base,valMean
    #  print name,base,valStd
    leg1 = ax1.plot(valMean, paramBase[base], label=baseMap[base], c=colA)
    ax1.plot(valMean - valStd,
             paramBase[base],
             '--',
             label=baseMap[base],
             c=colA,
             lw=2,
             alpha=0.7)
    ax1.plot(valMean + valStd,
             paramBase[base],
             '--',
             label=baseMap[base],
             c=colA,
             lw=2,
             alpha=0.7)
    ax1.fill_betweenx(paramBase[base],
                      valMean - valStd,
                      valMean + valStd,
                      color=colA,
                      alpha=0.3)
    if name == '$K$':
        leg1 += ax1.plot([30] * len(paramBase[base]),
                         paramBase[base],
                         '--',
                         label="$K_{T} = 30$",
                         c=colorScheme('labelMap')['red'])
    ax1.set_ylabel(paramName[base], color=colA)
    ax1.set_ylim(paramBase[base].min(), paramBase[base].max())
    ax1.invert_yaxis()
    for tl in ax1.get_yticklabels():
        tl.set_color(colA)
    tiks = ax1.get_yticks()
    tikLbl = [str(tik) for tik in tiks[:-1]]
    tikLbl += ['']
    ax1.set_yticklabels(tikLbl)
    #  ax1.legend(loc='best')
    ax1.set_xlabel(name)
    if False and name == 'NMI':
        tiks = ax1.get_xticks()
        tikLbl = []
        for tik in tiks[::2]:
            tikLbl += [str(tik), '']
        del tikLbl[-1]
        ax1.set_xticklabels(tikLbl)

    ax2 = ax1.twinx()
    base = 'DPvMFmeans'
    valMean = values[base].mean(axis=1)
    valStd = values[base].std(axis=1)
    #  print name,base,valMean
    #  print name,base,valStd
    leg2 = ax2.plot(values[base].mean(axis=1),
                    paramBase[base],
                    label=baseMap[base],
                    c=colB)
    ax2.plot(valMean - valStd,
             paramBase[base],
             '--',
             label=baseMap[base],
             c=colB,
             lw=2,
             alpha=0.7)
    ax2.plot(valMean + valStd,
             paramBase[base],
             '--',
             label=baseMap[base],
             c=colB,
             lw=2,
             alpha=0.7)
    ax2.fill_betweenx(paramBase[base],
                      valMean - valStd,
                      valMean + valStd,
                      color=colB,
                      alpha=0.3)
    if not Ns is None:  # and not name == '$K$':
        xlim = ax2.get_xlim()
        # first to spkm
        base = 'spkm'
        Nmean = Ns[base].mean(axis=1)
        #    iKtrue = np.where(np.abs(Nmean-30)<2)
        #    ax1.plot(values[base].mean(axis=1)[iKtrue],paramBase[base][iKtrue],'x',mew=4,ms=15,label=baseMap[base]+' $K={}$'.format(Nmean[iKtrue]),c=colorScheme('labelMap')['red'])
        iKtrue = np.argmin(np.abs(Nmean - 30))
        ax1.plot([xlim[0], values[base].mean(axis=1)[iKtrue]],
                 [paramBase[base][iKtrue], paramBase[base][iKtrue]],
                 '-',
                 mew=4,
                 ms=15,
                 label=baseMap[base] + ' \
        $K={}$'.format(Nmean[iKtrue]),
                 c=colA,
                 alpha=0.7)
        ax1.plot([xlim[0], values[base].mean(axis=1)[iKtrue]],
                 [paramBase[base][iKtrue], paramBase[base][iKtrue]],
                 '--',
                 mew=4,
                 ms=15,
                 label=baseMap[base] + ' \
        $K={}$'.format(Nmean[iKtrue]),
                 c=colorScheme('labelMap')['red'],
                 alpha=1.)
        # then do DPvMFmeans
        base = 'DPvMFmeans'
        Nmean = Ns[base].mean(axis=1)
        #    iKtrue = np.where(np.abs(Nmean-30)<2)
        #    ax2.plot(values[base].mean(axis=1)[iKtrue],paramBase[base][iKtrue],'x',mew=4,ms=15,label=baseMap[base]+' $K={}$'.format(Nmean[iKtrue]),c=colorScheme('labelMap')['red'])
        iKtrue = np.argmin(np.abs(Nmean - 30))
        ax2.plot([values[base].mean(axis=1)[iKtrue], xlim[1]],
                 [paramBase[base][iKtrue], paramBase[base][iKtrue]],
                 '-',
                 mew=4,
                 ms=15,
                 label=baseMap[base] + ' \
        $K={}$'.format(Nmean[iKtrue]),
                 c=colB,
                 alpha=0.7)
        ax2.plot([values[base].mean(axis=1)[iKtrue], xlim[1]],
                 [paramBase[base][iKtrue], paramBase[base][iKtrue]],
                 '--',
                 mew=4,
                 ms=15,
                 label=baseMap[base] + ' \
        $K={}$'.format(Nmean[iKtrue]),
                 c=colorScheme('labelMap')['red'],
                 alpha=1.)
        ax1.set_xlim(xlim)
        ax2.set_xlim(xlim)
    ax2.set_ylabel(paramName[base], color=colB)
    for tl in ax2.get_yticklabels():
        tl.set_color(colB)
    tiks = ax2.get_yticks()
    tikLbl = ax2.get_yticklabels()
    tikLbl = ['']
    tikLbl += [str(tik) for tik in tiks[1:]]
    ax2.set_yticklabels(tikLbl)
    ax2.set_ylim(paramBase[base].min(), paramBase[base].max())
    if False and name == 'NMI':
        tiks = ax2.get_xticks()
        tikLbl = []
        for tik in tiks[::2]:
            tikLbl += [str(tik), '']
        del tikLbl[-1]
        ax2.set_xticklabels(tikLbl)
    if not showLeg is None and showLeg:
        legs = leg2 + leg1
        labs = [leg.get_label() for leg in legs]
        ax2.legend(legs, labs, loc='best', prop={'size': legendSize})
    plt.tight_layout()
    plt.subplots_adjust(right=0.85, bottom=0.3)
    return fig
Example #20
0
def plotOverParams(values,
                   name,
                   paramBase,
                   paramName,
                   baseMap,
                   bases,
                   Ns=None,
                   showLeg=None):
    colA = colorScheme('labelMap')['orange']
    colB = colorScheme('labelMap')['turquoise']

    fig = plt.figure(figsize=figSize, dpi=80, facecolor='w', edgecolor='k')
    ax1 = plt.subplot(111)
    leg1 = []
    for base in bases:
        if base == 'spkm':
            valMean = values[base].mean(axis=1)
            valStd = values[base].std(axis=1)
            #  print name,base,valMean
            #  print name,base,valStd
            leg1 = ax1.plot(paramBase[base],
                            valMean,
                            label=baseMap[base],
                            c=colA)
            ax1.plot(paramBase[base],
                     valMean - valStd,
                     '--',
                     label=baseMap[base],
                     c=colA,
                     lw=2,
                     alpha=0.7)
            ax1.plot(paramBase[base],
                     valMean + valStd,
                     '--',
                     label=baseMap[base],
                     c=colA,
                     lw=2,
                     alpha=0.7)
            ax1.fill_between(paramBase[base],
                             valMean - valStd,
                             valMean + valStd,
                             color=colA,
                             alpha=0.3)
            if name == '$K$':
                leg1 += ax1.plot(paramBase[base], [30] * len(paramBase[base]),
                                 '--',
                                 label="$K_{T} = 30$",
                                 c=colorScheme('labelMap')['red'])
            ax1.set_xlabel(paramName[base], color=colA)
            ax1.xaxis.set_label_coords(0.5, -0.08)
            ax1.set_xlim(paramBase[base].min(), paramBase[base].max())
            ax1.invert_xaxis()
            for tl in ax1.get_xticklabels():
                tl.set_color(colA)
            tiks = ax1.get_xticks()
            tikLbl = ["{}".format(int(tik)) for tik in tiks[:-1]] + ['']
            ax1.set_xticklabels(tikLbl)
            #  ax1.legend(loc='best')
            ax1.set_ylabel(name)
            if False and name == 'NMI':
                tiks = ax1.get_yticks()
                tikLbl = []
                for tik in tiks[::2]:
                    tikLbl += [str(tik), '']
                del tikLbl[-1]
                ax1.set_yticklabels(tikLbl)
        elif base == 'DPvMFmeans':
            ax2 = ax1.twiny()
            valMean = values[base].mean(axis=1)
            valStd = values[base].std(axis=1)
            #  print name,base,valMean
            #  print name,base,valStd
            leg2 = ax2.plot(paramBase[base],
                            values[base].mean(axis=1),
                            label=baseMap[base],
                            c=colB)
            ax2.plot(paramBase[base],
                     valMean - valStd,
                     '--',
                     label=baseMap[base],
                     c=colB,
                     lw=2,
                     alpha=0.7)
            ax2.plot(paramBase[base],
                     valMean + valStd,
                     '--',
                     label=baseMap[base],
                     c=colB,
                     lw=2,
                     alpha=0.7)
            ax2.fill_between(paramBase[base],
                             valMean - valStd,
                             valMean + valStd,
                             color=colB,
                             alpha=0.3)
            ax2.set_xlabel(paramName[base], color=colB)
            ax2.xaxis.set_label_coords(0.5, 1.12)
            for tl in ax2.get_xticklabels():
                tl.set_color(colB)
            tiks = ax2.get_xticks()
            tikLbl = ax2.get_xticklabels()
            tikLbl = [''] + [str(int(tik)) for tik in tiks[1:]]
            ax2.set_xticklabels(tikLbl)
            ax2.set_xlim(paramBase[base].min(), paramBase[base].max())
            if False and name == 'NMI':
                tiks = ax2.get_yticks()
                tikLbl = []
                for tik in tiks[::2]:
                    tikLbl += [str(tik), '']
                del tikLbl[-1]
                ax2.set_yticklabels(tikLbl)
            if not showLeg is None and showLeg:
                legs = leg2 + leg1
                labs = [leg.get_label() for leg in legs]
                ax2.legend(legs, labs, loc='best', prop={'size': legendSize})
            plt.tight_layout()
            plt.subplots_adjust(right=0.85, bottom=0.3)
    return fig
Example #21
0
tau = np.array([0.1, 1.0, 10.0, 100.0])

d = mu[0] * x + mu[1] * y

ed = tau[:, np.newaxis] / (4.0 * np.pi * spec.iv(
    0, tau[:, np.newaxis])) * np.exp(tau[:, np.newaxis] * d)
edmax = tau[:, np.newaxis] / (
    4.0 * np.pi * spec.iv(0, tau[:, np.newaxis])) * np.exp(tau[:, np.newaxis])

for i in range(0, ed.shape[0]):
    fig = plt.figure(facecolor='white')
    ax = plt.axes(frameon=False)

    plt.plot(x, y, color='k', lw=5)
    plt.plot((1.0 + ed[i, :] / edmax[i]) * x, (1.0 + ed[i, :] / edmax[i]) * y,
             color=colorScheme('labelMap')['turquoise'],
             lw=5)
    for j in range(0, x.shape[0], 10):
        plt.plot(np.array([x[j], (1.0 + ed[i, j] / edmax[i]) * x[j]]),
                 np.array([y[j], (1.0 + ed[i, j] / edmax[i]) * y[j]]),
                 lw=1.,
                 color=colorScheme('labelMap')['turquoise'])
#    samps = sampleVMF(mu, tau[i], 50)
#    plt.scatter(samps[0, :], samps[1, :], c=colorScheme('labelMap')['orange'], s=200)
    plt.quiver(0,
               0,
               1.0 / np.sqrt(2),
               1.0 / np.sqrt(2),
               lw=1,
               color='k',
               angles='xy',