def plotSurface(cell, ax, color, surface=False, alpha=0.6, zorder=10):
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
###############################################################
# Plotting the Cell #
###############################################################
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
faceCounter = 0
xcenarray = []
ycenarray = []
zcenarray = []
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID() #grabbing face id
xlist = []
ylist = []
zlist = []
#print "== Face ID : ", faceid, "=="
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist, zlist)]
if surface:
pc = Poly3DCollection(verts,
alpha=alpha,
facecolor=color,
linewidths=1,
zorder=zorder)
pc.set_edgecolor(color)
ax.add_collection3d(pc)
else:
ax.plot(xlist, ylist, zlist, c=color, lw=3)
face = faces.next()
faceCounter += 1
return
def getNeighbourFaces(cell,faceid): faces = qd.CellFaceIterator(cell) face = faces.next() faceidarray = [faceid] while face != None: if face.getID() == faceid : edges = qd.FaceEdgeIterator(face) edge = edges.next() while edge != None: faceidarray.append(edge.Right().getID()) edge = edges.next() break face =faces.next() return faceidarray
def checkFastGrowing(targetid, i):
fastGrowing = [targetid]
faces = qd.CellFaceIterator(cell)
face = faces.next()
while (face != None):
if face.getID() == targetid:
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
rightFace = edge.Right()
fastGrowing.append(rightFace.getID())
edge = edges.next()
#print "kappa for this face : ", face.getKappa()
face = faces.next()
if i in fastGrowing:
return True
return False
def slowGrowth(cell,faceid):
faces = qd.CellFaceIterator(cell)
face = faces.next()
while (face != None):
if face.getID() == faceid:
print "Slowed Growth ID :", faceid
#print face.getKappa()
face.setKappa(1.5)
face.setGrowthVar(0.5)
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
rightFace = edge.Right()
rightFace.setKappa(1.5)
rightFace.setGrowthVar(0.5)
edge = edges.next()
face = faces.next()
return
def fastGrowth(cell, faceid, fastkappa, fastgrowthvar):
faces = qd.CellFaceIterator(cell)
face = faces.next()
while (face != None):
if face.getID() == faceid:
print "Setting Fast Kappa Growth for Face ID :", faceid
#print face.getKappa()
face.setKappa(fastkappa)
face.setGrowthVar(fastgrowthvar)
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
rightFace = edge.Right()
rightFace.setKappa(fastkappa)
rightFace.setGrowthVar(fastgrowthvar)
edge = edges.next()
print "kappa for this face : ", face.getKappa()
face = faces.next()
return cell
def targetFaceGrow(cell, faceid):
faces = qd.CellFaceIterator(cell)
face = faces.next()
while (face != None):
if face.getID() == faceid:
print "###################################################################################################"
print "Growing face %d & the neighbourhoodwith kappa : %.3f and growthvar : %.3f" % (
faceid, face.getKappa(), face.getGrowthVar())
print "###################################################################################################"
face.feedbackInflatedGrow()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
rightFace = edge.Right()
rightFace.feedbackInflatedGrow()
edge = edges.next()
face = faces.next()
cell.setParameters()
return cell
def getIntrinsicCoordinates(cell, targetfaceid):
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
faceid = face.getID()
if faceid != targetfaceid:
face = faces.next()
continue
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
x = []
y = []
while edge != None:
vertex = edge.Dest()
## Getting coordinates
x.append(vertex.getProjectedXcoordinate(targetfaceid))
y.append(vertex.getProjectedYcoordinate(targetfaceid))
edge = edges.next()
break
x.append(x[0])
y.append(y[0])
return x, y
def plotAbsAnisotropyStress(cell, numOfLayer,step = None, alpha = 0.8, Length=1.0,save=False,azim = -60, elev=50,
colormap = 'magma'):
import matplotlib.colors as colors
import matplotlib.cm as cmx
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer>1)*(np.sqrt(3.)*(numOfLayer-1)-Length)+Length#the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=True,figsize=(22,10))
#fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax1 = fig.add_subplot(121,projection='3d')
ax2 = fig.add_subplot(122,projection='3d')
#ax = Axes3D(fig)
xlim = 0.5
ax1.set_xlim((-xlim*radius,xlim*radius))
ax1.set_ylim((-xlim*radius,xlim*radius))
ax1.set_zlim((-0.3*radius,0.7*radius))
ax1.axis('off')
ax1.xaxis.pane.set_edgecolor('black')
ax1.yaxis.pane.set_edgecolor('black')
#################################################
ax2.set_xlim((-xlim*radius,xlim*radius))
ax2.set_ylim((-xlim*radius,xlim*radius))
ax2.set_zlim((-0.3*radius,.7*radius))
ax2.axis('off')
ax2.xaxis.pane.set_edgecolor('black')
ax2.yaxis.pane.set_edgecolor('black')
#ax.xaxis.pane.fill = False
#ax.yaxis.pane.fill = False
#ax.zaxis.pane.fill = False
########################################################################
# Plotting the Strain vectors #
########################################################################
X = []
Y = []
Z = []
U = []
V = []
W = []
eigenvalue =[]
eigenvalue1array = []
eigenvalue2array = []
eigenvalueratioarray = []
eigenvaluedifferencearray = []
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
if face.getID() == 1:
face = faces.next()
continue
if sf.checkExternalFace(face):
face = faces.next()
continue
eigenvec1 = face.getStressEigenVector1()
eigenvec2 = face.getStressEigenVector2()
eigenvalue1 = face.getStressEigenValue1()
eigenvalue2 = face.getStressEigenValue2()
eigenvalue.append(eigenvalue1)
eigenvalue.append(eigenvalue2)
eigenvalue1array.append(eigenvalue1)
eigenvalue2array.append(eigenvalue2)
eigen1 = eigenvalue1
eigen2 = eigenvalue2
#ratio = (max(eigen1,eigen2)- min(eigen1,eigen2))/max(eigen1,eigen2)
ratio = getAbsAnistropy(eigen1,eigen2)#(max(eigen1,eigen2)- min(eigen1,eigen2))/(eigen1+eigen2)
diff = getDifference(eigen1,eigen2)
eigenvalueratioarray.append(ratio)
eigenvaluedifferencearray.append(diff)
#########~~~ EIGEN VEC 1 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec1,0))
V.append(qd.doublearray_getitem(eigenvec1,1))
W.append(qd.doublearray_getitem(eigenvec1,2))
#########~~~ EIGEN VEC 2 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec2,0))
V.append(qd.doublearray_getitem(eigenvec2,1))
W.append(qd.doublearray_getitem(eigenvec2,2))
#ax.scatter(X[-1],Y[-1],Z[-1])
face = faces.next()
###getting Maximum Eigenvalue ratio
maxEigenValueRatio = (max(eigenvalueratioarray))
minEigenValueRatio = (min(eigenvalueratioarray))
maxEigenValue = max(map(abs,eigenvalue))
maxEigendiff = max(eigenvaluedifferencearray)
minEigendiff = min(eigenvaluedifferencearray)
#print "Max Eigen Value Ration :", maxEigenValueRatio
#print "Min Eigen Value Ratio :", minEigenValueRatio
############################################
# Plotting the Cell #
############################################
######### Color Map A ######################
jet1 = cm1 = plt.get_cmap(colormap)
maxvalue = 1.0
minvalue = 0.
normMax = 1 # value to normalize by
cNorm1 = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap1 = cmx.ScalarMappable(norm=cNorm1, cmap=jet1)
######### Color Map B ######################
jet2 = cm2 = plt.get_cmap(colormap)
maxvalue = maxEigendiff
minvalue = minEigendiff
normMax = 1 # value to normalize by
cNorm2 = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap2 = cmx.ScalarMappable(norm=cNorm2, cmap=jet2)
###################
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
xcenarray = []
ycenarray = []
zcenarray = []
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID()#grabbing face id
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist,zlist)]
#adding to 3d plot
xcenarray.append(face.getXCentralised())
ycenarray.append(face.getYCentralised())
zcenarray.append(face.getZCentralised())
eigenvec1 = face.getStressEigenVector1()
eigenvec2 = face.getStressEigenVector2()
eigenvalue1 = face.getStressEigenValue1()
eigenvalue2 = face.getStressEigenValue2()
eigenvalue.append(eigenvalue1)
eigenvalue.append(eigenvalue2)
eigenvalue1array.append(eigenvalue1)
eigenvalue2array.append(eigenvalue2)
eigen1 = eigenvalue1
eigen2 = eigenvalue2
#ratio = (max(eigen1,eigen2)- min(eigen1,eigen2))/max(eigen1,eigen2)
absratio = getAbsAnistropy(eigen1,eigen2)#(max(eigen1,eigen2)- min(eigen1,eigen2))/(eigen1+eigen2)
diffratio = getDifference(eigen1,eigen2)#(max(eigen1,eigen2)- min(eigen1,eigen2))/(eigen1+eigen2)
#####################################################################
if sf.checkExternalFace(face):
absratio = 0.
diffratio = 0.
#print "face ID : ", face.getID(), " ratio : ", ratio
color1 = scalarMap1.to_rgba(absratio)
color2 = scalarMap2.to_rgba(diffratio)
#print face.getID(), ratio
#print face.getZCentralised(), alpha_fac
#ax.add_collection3d(arrow(xcen-0.5,ycen-0.5,zcen-0.5,xcen+0.5,ycen+0.5,zcen+0.5))
pc = Poly3DCollection(verts,alpha = alpha,facecolor = color1,linewidths=1,zorder=0)
pc.set_edgecolor('k')
ax1.add_collection3d(pc)
ax1.scatter(xcenarray[-1], ycenarray[-1],zcenarray[-1],c='r')
###########################################################################################
pc = Poly3DCollection(verts,alpha = alpha,facecolor = color2,linewidths=1,zorder=0)
pc.set_edgecolor('k')
ax2.add_collection3d(pc)
ax2.scatter(xcenarray[-1], ycenarray[-1],zcenarray[-1],c='r')
#ax.text(xcenarray[-1], ycenarray[-1],zcenarray[-1],face.getID(),fontsize = 18)
face = faces.next()
#if face.getID() == 1: break
#plt.clf()
for i in range(len(X)):
veclength = np.sqrt((U[i])**2+(V[i])**2+(W[i])**2)
#print " veclength : ", veclength, (eigenvalue[i]/maxEigenValue)
veclength *= (eigenvalue[i]/maxEigenValue)
if veclength <= 0:
colorvec = 'r'
else:
colorvec = 'k'
plot1 = ax1.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color=colorvec,length = veclength,pivot='tail',zorder=-1)
plot2 = ax2.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color=colorvec,length = veclength,pivot='tail',zorder=-1)
#ax.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color='k',pivot='tail',zorder=4)# for older matplotlib
scalarMap1._A = []
scalarMap2._A = []
#cbar_ax = fig.add_axes([0.78, 0.2, 0.04, 0.55])
#clrbar = plt.colorbar(scalarMap,shrink=0.5, aspect=10)
#clrbar = plt.colorbar(scalarMap,cax = cbar_ax,ticks=np.linspace(minvalue,maxvalue,5))#,orientation='horizontal',cax = cbar_ax)
clrbar1 = plt.colorbar(scalarMap1, ax=ax1,shrink = 0.5,aspect = 10,ticks=np.linspace(0,1,5))#,orientation='horizontal',cax = cbar_ax)
clrbar1.set_label(r"Stress Anisotrophy $(s_a)$")
clrbar2 = plt.colorbar(scalarMap2, ax=ax2,shrink = 0.5,aspect = 10, ticks=np.linspace(minvalue,maxvalue,5))#,orientation='horizontal',cax = cbar_ax)
clrbar2.set_label(r"Stress Difference $(s_d)$")
#ax.set_title("Time %d : Anisotrophy of Strain : Max %.4f Min %.4f"%(step,maxEigenValueRatio,minEigenValueRatio), fontsize = 20)
#print xcenarray-0.5
#plt.close("all")
ax1.view_init(azim = azim, elev= elev)
ax2.view_init(azim = azim, elev= elev)
if save:
saveDirectory = "strainFigures_u=%03d_v=%03d"%(azim,elev)+r"/stressSurface"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
#plt.tight_layout()
#plt.savefig(saveDirectory+r"/strainSurface_Time=%03d.eps"%(step),dpi = 500,format='eps', transparent=True)
plt.savefig(saveDirectory+r"/stressAnisotropy_Time=%03d.png"%(step),dpi = 500,format='png', transparent=True)
plt.close()
return# eigenvalueratioarray
def plotMeanGrowthRate(step,
numOfLayer=8,
eta=0,
targetface=10,
alpha=0.8,
Length=1.0,
save=False,
azim=-70,
elev=50):
import matplotlib.colors as colors
import matplotlib.cm as cmx
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer >
1) * (np.sqrt(3.) * (numOfLayer - 1) -
Length) + Length #the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=False, figsize=(10, 8))
#fig = plt.figure(frameon=False)
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax = Axes3D(fig)
ax.set_xlim((-0.7 * radius, 0.7 * radius))
ax.set_ylim((-0.7 * radius, 0.7 * radius))
ax.set_zlim((-0., 1.4 * radius))
ax.axis('off')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
#ax.xaxis.pane.fill = False
#ax.yaxis.pane.fill = False
#ax.zaxis.pane.fill = False
#######################################################################
# Checking if the files exists if not going to step down
try:
#cell = qd.objReadCell("qdObject_step=%03d.obj"%step)
cell = sf.loadCellFromFile(step)
#print "success"
except:
#print " exception reached"
step -= 1
#sys.stdout.write("step : ", step , os.getcwd())
#sys.stdout.flush()
#print "step : ", step , os.getcwd()
plotMeanGrowthRate(step, azim=azim, elev=elev, eta=eta, save=save)
return
#print "Step : ", step
########################################################################
# Loading the step-1 step #
########################################################################
completeFaceArray = getFaceAreaArray(step)
rateDict = {}
for key in completeFaceArray:
value = np.array(completeFaceArray[key])
rateDict[key] = np.mean(np.array(getRates(value)))
####################################################################################
# PLotting the faces now
####################################################################################
cell = qd.objReadCell("qdObject_step=%03d.obj" % step)
# Flipping the Face ID after Loading to cell so that the face id before and after matches
faces = qd.CellFaceIterator(cell)
facecount = cell.countFaces()
face = faces.next()
while face != None:
faceid = face.getID()
face.setID(facecount - faceid + 1)
#print face.getID()
face = faces.next()
######################################################
#settig target Form Matrix :
#TMF step corresponds to coordinate step
####
cell = sf.setTargetFormMatrix(cell, step)
cell.setParameters()
#calculating forces, stress-matrix and strain-matrix
#cell.calculateVertexForce()
cell.calculateStrain()
######## ######## ######## ######## ########
# Plotting the Cell #
######## ######## ######## ######## ########
######### Color Map
jet = cm = plt.get_cmap('viridis')
maxvalue = 0.006
minvalue = 0.
#print "Max value", maxvalue, " minvalue", minvalue
cNorm = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
xcenarray = []
ycenarray = []
zcenarray = []
counter = 0
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID() #grabbing face id
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist, zlist)]
#adding to 3d plot
xcenarray.append(face.getXCentralised())
ycenarray.append(face.getYCentralised())
zcenarray.append(face.getZCentralised())
#print "face ID : ", face.getID(), " ratio : ", ratio
#ratio = (face.getStrainTrace()+minTrace)/(minTrace+maxTrace)
"""if sf.checkExternalFace(face):
ratio = 0.
color = scalarMap.to_rgba(ratio)
else:
"""
ratio = rateDict[face.getID()]
#print ratio
color = scalarMap.to_rgba(ratio)
#print ratio
#print face.getZCentralised(), alpha_fac
#ax.add_collection3d(arrow(xcen-0.5,ycen-0.5,zcen-0.5,xcen+0.5,ycen+0.5,zcen+0.5))
pc = Poly3DCollection(verts,
alpha=alpha,
facecolor=color,
linewidths=1,
zorder=0)
pc.set_edgecolor('k')
ax.add_collection3d(pc)
ax.scatter(xcenarray[-1], ycenarray[-1], zcenarray[-1], c='r')
face = faces.next()
#if face.getID() == 1: break
#plt.clf()
ax.view_init(azim=azim, elev=elev)
scalarMap._A = []
ax.set_title("Mean Growth Rate Step %d" % step)
cbar_ax = fig.add_axes([0.873, 0.2, 0.04, 0.55])
clrbar = plt.colorbar(
scalarMap, cax=cbar_ax) #,orientation='horizontal',cax = cbar_ax)
clrbar.ax.tick_params(labelsize=20)
clrbar.set_label("Growth Rate step", fontsize=30)
#ax.set_title("Time %d : Magnitude of Strain : Max %.4f ; Min %.4f"%(step,maxTrace,minTrace), fontsize = 20)
#print xcenarray-0.5
#plt.close("all")
if save:
saveDirectory = "../meanGrowthRate"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
plt.savefig(saveDirectory + r"/meanGrowthRate_eta=%.3f_time=%03d.png" %
(eta, step),
transparent=True)
plt.close()
return
def plotTargetGrowSurface(cell, numOfLayer, step = None, targetid = 135,
ids = False,save = False, alpha = 0.8, Length=1.0,azim = -60.,elev=60,figsize = (20,16)):
#calculating forces, stress-matrix and strain-matrix
cell.calculateVertexForce()
cell.calculateStressStrain()
import matplotlib.colors as colors
import matplotlib.cm as cmx
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer>1)*(np.sqrt(3.)*(numOfLayer-1)-Length)+Length#the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=False,figsize=figsize)
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
#fig.set_aspect(aspect='equal', adjustable='box')
ax = Axes3D(fig)
ax.set_xlim((-.5*radius,.5*radius))
ax.set_ylim((-.5*radius,.5*radius))
ax.set_zlim((-0.,1.*radius))
ax.axis('off')
#ax.axis('equal')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
########################################################################
# Plotting the Cell #
########################################################################
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
faceids = []
while (face != None):
if face.getID() ==1:
face = faces.next()
continue
faceid = face.getID()#grabbing face id
xlist = []
ylist = []
zlist = []
faceids.append(faceid)
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
#print faceid
###############################################
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
#ax.plot(xlist,ylist,zlist,'k',lw = 2)
verts = [zip(np.array(xlist),np.array(ylist),np.array(zlist))]
#pc = Poly3DCollection(verts,alpha = 0.1,linewidths = 4,zorder = 1, facecolor = 'w')
#pc.set_edgecolor('k')
#ax.add_collection3d(pc)
ax.plot(xlist,ylist,zlist,'k',lw = 3)
if ids:
ax.text(xmean,ymean,zmean, face.getID(),fontsize = 20)
face = faces.next()
#if face.getID() == 1: break
#plt.clf()
##PLOTTING ELLIPSE
#numofface = cell.countFaces()
#faceids = getNeighbouringFaces(cell,targetid)
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
#face id :
i = face.getID()
if i == 1:
face = faces.next()
continue
# Strain
strainellipsepoints = getStrainEllipsePoints(cell,i,factor=4)
verts = [zip(np.array(strainellipsepoints[0])[0],np.array(strainellipsepoints[1])[0], np.array(strainellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = 1.,linewidth=0,zorder = 100, facecolor = 'k')
pc.set_edgecolor('k')
ax.add_collection3d(pc)
# Target Form
TFellipsepoints = getTargetFormEllipsePoints(cell,i)
verts = [zip(np.array(TFellipsepoints[0])[0],np.array(TFellipsepoints[1])[0], np.array(TFellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = .7,linewidth=0, facecolor = 'r',zorder = 10,label="TFM" if i == 0 else "")
pc.set_edgecolor('k')
#ax.add_collection3d(pc)
# Current Form
CFellipsepoints = getCurrentFormEllipsePoints(cell,i)
verts = [zip(np.array(CFellipsepoints[0])[0],np.array(CFellipsepoints[1])[0], np.array(CFellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = 0.5,linewidth=0,zorder = 5, facecolor = 'g')
pc.set_edgecolor('k')
#ax.add_collection3d(pc)
#######################
face = faces.next()
### Now do growth on the target faces
cell = sf.feedbackStrainGrowFaces(cell)
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
#face id :
i = face.getID()
if i == 1:
face = faces.next()
continue
if checkFastGrowing(targetid, i):
facecolor = 'g'
else:
facecolor = 'm'
# Target Form
TFellipsepoints = getTargetFormEllipsePoints(cell,i)
verts = [zip(np.array(TFellipsepoints[0])[0],np.array(TFellipsepoints[1])[0], np.array(TFellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = .5,linewidth=0, facecolor = facecolor,zorder = 10,label="TFM" if i == 0 else "")
pc.set_edgecolor('k')
ax.add_collection3d(pc)
face = faces.next()
ax.view_init(azim = azim,elev=elev)
#scatter1_proxy = mpl.lines.Line2D([0],[0], linestyle="none", c='r', marker = 's',ms=50)
scatter2_proxy = mpl.lines.Line2D([0],[0], linestyle="none", c='g', marker = 's',ms=50)
scatter3_proxy = mpl.lines.Line2D([0],[0], linestyle="none", c='k', marker = 's',ms=50)
scatter4_proxy = mpl.lines.Line2D([0],[0], linestyle="none", c='m', marker = 's',ms=50)
ax.set_title("Feedback Growth and strain visualised step %d"%step)
ax.legend([ scatter2_proxy,scatter3_proxy,scatter4_proxy], ['Target Shape', 'Fast Growing',"Strain","Normal Growing"],fontsize = 30, numpoints = 1,loc = 0)
if save:
saveDirectory = "strainFigures_u=%03d_v=%03d"%(azim,elev)+r"/ellipsePlot"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
plt.savefig(saveDirectory+r"/ellipsePlot_Time=%03d.png"%(step),transparent=True)
plt.close()
#ax.text(0,0,0,'P',fontsize = 50,zorder=-1)
#plt.suptitle("Step =%03d"%step,fontsize = 30)
#plt.savefig('initial_TFM_layer8.png', transparent=True)
return
def plotSurfaceStressGrowthRate(plotData,
numOfLayer,
eta=etacurrent,
name=None,
alpha=0.5,
Length=1.0,
ids=False,
azim=0,
elev=7,
color='c',
format='eps',
zaxisoffset=0.2):
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer >
1) * (np.sqrt(3.) * (numOfLayer - 1) -
Length) + Length #the radius of circle to be projected on
###############################################################################
# getting data information
# format of plotData : [tissueSurfaceAreaArray,tissueSurfaceAreaArray2,
# heightArray, timeArray,timeArray2, dictArray]
# # dictArray = [absStressDict, stressRadialDict,
# stressOrthoradialDict,growthRateDict, tipDistanceDict]
###############################################################################
laststep = plotData[4][-1]
############################################################
#getting the dicts
dictArray = plotData[5]
absstressDict = dictArray[
0] # stresses are computed as total abs stress on a cell
growthrateDict = dictArray[3]
############################################################
maxstress = max(absStressDict[max(absStressDict.keys(),
key=lambda k: max(absStressDict[k]))])
minstress = min(absStressDict[min(absStressDict.keys(),
key=lambda k: min(absStressDict[k]))])
############################################################
maxgrowthrate = max(growthrateDict[max(
growthrateDict.keys(), key=lambda k: max(growthrateDict[k]))])
mingrowthrate = min(growthrateDict[min(
growthrateDict.keys(), key=lambda k: min(growthrateDict[k]))])
###############################################################################
# colorbar
###############################################################################
# for stress
jet1 = cm = plt.get_cmap('inferno')
cNorm1 = colors.Normalize(vmin=minstress, vmax=maxstress)
scalarMapStress = cmx.ScalarMappable(norm=cNorm1, cmap=jet1)
# for growth
jet2 = cm = plt.get_cmap('cool')
cNorm2 = colors.Normalize(vmin=mingrowthrate, vmax=maxgrowthrate)
scalarMapGrowth = cmx.ScalarMappable(norm=cNorm2, cmap=jet2)
###############################################################################
#plotting part
###############################################################################
fig = plt.figure(1, frameon=False, figsize=(12, (1. - zaxisoffset) * 10))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax = Axes3D(fig)
ax.set_xlim((-.7 * radius, .7 * radius))
ax.set_ylim((-.7 * radius, .7 * radius))
ax.set_zlim((0 * radius, (1. - zaxisoffset) * 1.4 * radius))
ax.axis('off')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
fig2 = plt.figure(2, frameon=False, figsize=(12, (1. - zaxisoffset) * 10))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax = Axes3D(fig)
ax.set_xlim((-.7 * radius, .7 * radius))
ax.set_ylim((-.7 * radius, .7 * radius))
ax.set_zlim((0 * radius, (1. - zaxisoffset) * 1.4 * radius))
ax.axis('off')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
#fig = plt.figure()
#ax = fig.gca(projection='3d')
##iterating through the cell##
faces = qd.CellFaceIterator(cell)
face = faces.next()
while (face != None):
faceid = face.getID() #grabbing face id
if face.getID() == 1:
face = faces.next()
continue
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist, zlist)]
#adding to 3d plot
pc = Poly3DCollection(verts,
alpha=alpha,
linewidths=1,
facecolor=color)
pc.set_edgecolor('k')
ax.add_collection3d(pc)
# adding ids for face
if ids:
ax.text(xmean, ymean, zmean, faceid)
face = faces.next()
#if face.getID() == 1: break
#ax.axis("off")
ax.view_init(azim=azim, elev=elev)
if name == None: #plot the figure
plt.show()
else:
if format == None:
plt.savefig(name, transparent=True)
else:
plt.savefig(name + "." + format, transparent=True, format=format)
#plt.clf()
return
def plotGrowthDirection(cell, diffmatrix, plotdiff,step,targetface, azim = -60, elev = 30, saveDirectory = None):
# Iterating over Face
# getting neighbourhood of fast groing cell
######### Color Map ####################################
import matplotlib.colors as colors
import matplotlib.cm as cmx
jet = cm = plt.get_cmap('viridis')
maxvalue = 1.#np.pi/2
minvalue = 0.#-1.*np.pi
cNorm = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
########################################################
faceidarray = getNeighbourFaces(cell,targetface)
primordialface = sf.getFace(cell,targetface)
px = primordialface.getXCentralised()
py = primordialface.getYCentralised()
pz = primordialface.getZCentralised()
plotdiff.scatter(px,py,pz,marker='*', c= 'm',s = 30)
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID()
if faceid in faceidarray:
c = 'g'
lw = 3
zoomfactor = 1
else:
c = 'k'
lw = 1.5
zoomfactor = 1
#######################################################
# Calculation of eigen vecs
#######################################################
facediffmatrix = diffmatrix[face.getID()]
#########################################
#Getting points to plot ellipse
ellipsepoints = getMatrixDifferenceEllipsePoints(cell,face.getID(),facediffmatrix,primordialfaceid = targetface,zoomfactor = zoomfactor)
###############################
eigvec, eigval, u = np.linalg.svd(facediffmatrix)
eigval = np.divide(eigval,np.max(eigval))
eigval = 10*eigval
#######################################################
# Getting the unit matrix for transformation
#######################################################
unitx = face.getUnitx()
unity = face.getUnity()
unitz = face.getUnitz()
transformMatrix = np.transpose(np.matrix(
[[qd.doublearray_getitem(unitx,0),qd.doublearray_getitem(unitx,1),qd.doublearray_getitem(unitx,2)],
[qd.doublearray_getitem(unity,0),qd.doublearray_getitem(unity,1),qd.doublearray_getitem(unity,2)],
[qd.doublearray_getitem(unitz,0),qd.doublearray_getitem(unitz,1),qd.doublearray_getitem(unitz,2)]]))
#################################
#print "#################################"
#print eigvec
eigvec = np.matrix(np.vstack((eigvec.T, [0,0])))
#print eigvec
eigvec = np.matmul(transformMatrix,eigvec).T
#print eigvec
#print transformMatrix
#################################
# Now plotting the eigenvecs
#################################
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
plotdiff.scatter(xmean,ymean,zmean,marker='*', c= 'b',s = 30)
################################################################################################
# Plotting the angle between the radial and primary direction
################################################################################################
################################################################################################
# Getting the angle for between radial and primary growth direction
################################################################################################
#print px, py, pz
############################################################
radialvec = np.array([px-xmean,py-ymean,pz-zmean])
try:
radialvec /= np.linalg.norm(radialvec)
except RuntimeWarning:
print px, py, pz
print xmean, ymean, zmean
radialvec = np.array([0.,0.,0.])
primaryvec = np.array([eigvec[0,0],eigvec[0,1],eigvec[0,2]])
primaryvec /= np.linalg.norm(primaryvec)
############################################################
# angle : here it means dot product
############################################################
angle= np.abs(np.dot(radialvec,primaryvec))
#print px, py, pz, xmean, ymean, zmean, "radialvec ", radialvec
#print "="*20
#print faceid, angle
color = scalarMap.to_rgba(angle)
#print eigvec, eigvec.shape, eigvec[0],eigval
xlist = []
ylist = []
zlist = []
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
plotdiff.text(xmean,ymean,zmean, "%.2f"%angle)
verts = [zip(xlist, ylist,zlist)]
#plotdiff.text(xmean, ymean, zmean, "%.2f"%(angle))
#verts = [zip(np.array(ellipsepoints[0])[0],np.array(ellipsepoints[1])[0], np.array(ellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = .7,linewidths=1, facecolor = color,zorder = 10)
pc.set_edgecolor(color)
plotdiff.add_collection3d(pc)
############################################################
# For now just plotting Principal direction of Growth
############################################################
"""plotdiff.quiver(xmean,ymean,zmean,
radialvec[0],radialvec[1],radialvec[2],
color='b',length = 1,pivot='tail',zorder=-1)"""
if eigval[0]> eigval[1]:
colorvec1 = 'r'
vec1 = plotdiff.quiver(xmean,ymean,zmean,
eigvec[0,0],eigvec[0,1],eigvec[0,2],
color=colorvec1,length = 1,pivot='tail',zorder=-1)
#colorvec2 = 'b'
else:
colorvec2 = 'r'
vec2 =plotdiff.quiver(xmean,ymean,zmean,
eigvec[1,0],eigvec[1,1],eigvec[1,2],
color=colorvec2,length = 1,pivot='tail',zorder=-1)
############################################################
# Plotting face
############################################################
xlist = []
ylist = []
zlist = []
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
if faceid in faceidarray:
line, = plotdiff.plot(xlist,ylist,zlist,c=c,lw = lw)
else:
plotdiff.plot(xlist,ylist,zlist,c=c,lw = lw)
face = faces.next()
plotdiff.view_init(azim = azim, elev= elev)
#plotdiff.legend((vec1,vec2,line),("major direction","minor direction","Fast Growing"),bbox_to_anchor=(0.87, 0.95))
########################################################################
plt.savefig(saveDirectory+r"/principalGrowth_step=%03d.png"%(step),transparent=True)
del plotdiff.collections[:]
plotdiff.lines = []
return plotdiff
faces = qd.CellFaceIterator(cell)
face1 = faces.next()
while face1 != None:
#print face1.getID()
face1.setProjectedCoordinate()
face1 = faces.next()
##########################################################################################################
# MAKING DOME
##########################################################################################################
# if the flat option is used next step to construct a dome is passed.
#constructing the dome of tissue
if not args.flat: #the dome is constructed in case the flat option is flase
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
vertex = edge.Dest()
x = vertex.getXcoordinate()
y = vertex.getYcoordinate()
#print radius**2 - x**2 - y**2
z = np.sqrt(np.abs(radius**2 - x**2 - y**2))
vertex.setZcoordinate(z)
edge = edges.next()
face = faces.next()
########################################################################################################################
#####################################################
for _ in range(1):
faces = qd.CellFaceIterator(cell)
face1 = faces.next()
def plotFaceArea(cell,
numOfLayer,
step=None,
alpha=0.8,
Length=1.0,
save=False,
azim=-70,
elev=50):
###########################################
### Making the directory to save the figure
###########################################
import os
directory = 'faceAreaPlot'
if not os.path.exists(directory):
os.makedirs(directory)
###########################################
### FORMATING FOR COLORBAR SCALE
###########################################
def fmt(x, pos):
a, b = '{:.2e}'.format(x).split('e')
b = int(b)
return r'${} \times 10^{{{}}}$'.format(a, b)
###########################################
#calculating forces, stress-matrix and strain-matrix
#cell.calculateVertexForce()
cell.calculateStrain()
import matplotlib.colors as colors
import matplotlib.cm as cmx
import matplotlib.ticker as ticker
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer >
1) * (np.sqrt(3.) * (numOfLayer - 1) -
Length) + Length #the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=False, figsize=(10, 8))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax = Axes3D(fig)
ax.set_xlim((-0.7 * radius, 0.7 * radius))
ax.set_ylim((-0.7 * radius, 0.7 * radius))
ax.set_zlim((-0., 1.4 * radius))
ax.axis('off')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
########################################################################
# Plotting the Stress vectors #
########################################################################
X = []
Y = []
Z = []
U = []
V = []
W = []
areaArray = []
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
if face.getID() == 1:
face = faces.next()
continue
areaArray.append(face.getAreaOfFace())
#################################################
face = faces.next()
###getting Maximum Eigenvalue ratio
maxMagnitude = 1 #(max(areaArray))
minMagnitude = 0 #(min(areaArray))
normMax = 12.
#print "Min & Max Magnitude", minMagnitude, maxMagnitude
###############################################################
# Plotting the Cell #
###############################################################
######### Color Map
jet = cm = plt.get_cmap('viridis')
cNorm = colors.Normalize(vmin=minMagnitude, vmax=maxMagnitude)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
faceCounter = 0
xcenarray = []
ycenarray = []
zcenarray = []
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID() #grabbing face id
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist, zlist)]
#adding to 3d plot
xcenarray.append(face.getXCentralised())
ycenarray.append(face.getYCentralised())
zcenarray.append(face.getZCentralised())
########################################################################################
color = scalarMap.to_rgba(face.getAreaOfFace() / normMax)
#print face.getZCentralised(), alpha_fac
#ax.add_collection3d(arrow(xcen-0.5,ycen-0.5,zcen-0.5,xcen+0.5,ycen+0.5,zcen+0.5))
pc = Poly3DCollection(verts,
alpha=alpha,
facecolor=color,
linewidths=1,
zorder=0)
pc.set_edgecolor('k')
ax.add_collection3d(pc)
ax.scatter(xcenarray[-1], ycenarray[-1], zcenarray[-1], 'o', c='r')
#ax.text(xcenarray[-1], ycenarray[-1],zcenarray[-1], face.getID())
face = faces.next()
faceCounter += 1
#if face.getID() == 1: break
#plt.clf()
#ax.view_init(elev=90., azim=0.)#viewing angle from top
scalarMap._A = []
#clrbar = plt.colorbar(scalarMap, format=ticker.FuncFormatter(fmt))
#clrbar.set_label("Area of Cell")
cbar_ax = fig.add_axes([0.873, 0.2, 0.04, 0.55])
#clrbar = plt.colorbar(scalarMap,shrink=0.5, aspect=10)
clrbar = plt.colorbar(
scalarMap, cax=cbar_ax) #,orientation='horizontal',cax = cbar_ax)
#clrbar = plt.colorbar(scalarMap,shrink=0.5, aspect=10)
clrbar.set_label("Area of Cell", fontsize=18)
clrbar.ax.tick_params(labelsize=14)
#ax.set_title("Time %d : Area of Cell : Max %.4f Min %.4f"%(step,maxMagnitude,minMagnitude), fontsize = 20)
ax.view_init(azim=azim, elev=elev)
if save:
saveDirectory = "strainFigures_u%02d_v%02d" % (
azim, elev) + r"/StressfaceArea"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
plt.savefig(saveDirectory + r"/faceArea_Time=%03d.png" % (step),
transparent=True)
plt.close()
#plt.close("all")
#return eigenvalueratioarray, eigenvalue1array, eigenvalue2array
return
def plotStrainSurface(cell,
numOfLayer,
step=None,
alpha=0.8,
Length=1.0,
save=False,
azim=-70,
elev=50):
import matplotlib.colors as colors
import matplotlib.cm as cmx
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer >
1) * (np.sqrt(3.) * (numOfLayer - 1) -
Length) + Length #the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=False, figsize=(10, 8))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax = Axes3D(fig)
ax.set_xlim((-0.7 * radius, 0.7 * radius))
ax.set_ylim((-0.7 * radius, 0.7 * radius))
ax.set_zlim((-0., 1.4 * radius))
ax.axis('off')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
#ax.xaxis.pane.fill = False
#ax.yaxis.pane.fill = False
#ax.zaxis.pane.fill = False
########################################################################
# Plotting the Strain vectors #
########################################################################
X = []
Y = []
Z = []
U = []
V = []
W = []
eigenvalue = []
eigenvalue1array = []
eigenvalue2array = []
eigenvalueratioarray = []
faces = qd.CellFaceIterator(cell)
face = faces.next()
while face != None:
if face.getID() == 1:
face = faces.next()
continue
if sf.checkExternalFace(face):
face = faces.next()
continue
eigenvec1 = face.getStrainEigenVector1()
eigenvec2 = face.getStrainEigenVector2()
eigenvalue1 = face.getStrainEigenValue1()
eigenvalue2 = face.getStrainEigenValue2()
eigenvalue.append(eigenvalue1)
eigenvalue.append(eigenvalue2)
eigenvalue1array.append(eigenvalue1)
eigenvalue2array.append(eigenvalue2)
ratio = abs(
max(eigenvalue1, eigenvalue2) -
min(eigenvalue1, eigenvalue2)) / max(abs(eigenvalue1),
abs(eigenvalue2))
eigenvalueratioarray.append(ratio)
#########~~~ EIGEN VEC 1 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec1, 0))
V.append(qd.doublearray_getitem(eigenvec1, 1))
W.append(qd.doublearray_getitem(eigenvec1, 2))
#########~~~ EIGEN VEC 2 ~~~#########
#getting the centralised coordinate of centroid
X.append(face.getXCentralised())
Y.append(face.getYCentralised())
Z.append(face.getZCentralised())
#getting the vector headings
U.append(qd.doublearray_getitem(eigenvec2, 0))
V.append(qd.doublearray_getitem(eigenvec2, 1))
W.append(qd.doublearray_getitem(eigenvec2, 2))
#ax.scatter(X[-1],Y[-1],Z[-1])
face = faces.next()
###getting Maximum Eigenvalue ratio
maxEigenValueRatio = (max(eigenvalueratioarray))
minEigenValueRatio = (min(eigenvalueratioarray))
maxEigenValue = max(map(abs, eigenvalue))
#print "Max Eigen Value Ration :", maxEigenValueRatio
#print "Min Eigen Value Ratio :", minEigenValueRatio
######## ######## ######## ######## ########
# Plotting the Cell #
######## ######## ######## ######## ########
######### Color Map
jet = cm = plt.get_cmap('plasma')
maxvalue = 1 #maxEigenValueRatio
minvalue = 0 #minEigenValueRatio
normMax = 2 # value to normalize by
cNorm = colors.Normalize(vmin=minvalue, vmax=maxvalue)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
xcenarray = []
ycenarray = []
zcenarray = []
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID() #grabbing face id
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist, zlist)]
#adding to 3d plot
xcenarray.append(face.getXCentralised())
ycenarray.append(face.getYCentralised())
zcenarray.append(face.getZCentralised())
#print face.getZCentralised()
eigenvalue1 = face.getStrainEigenValue1()
eigenvalue2 = face.getStrainEigenValue2()
ratio = abs(
max(eigenvalue1, eigenvalue2) - min(eigenvalue1, eigenvalue2)) / (
normMax * max(abs(eigenvalue1), abs(eigenvalue2)))
if sf.checkExternalFace(face):
ratio = 0.
#print "face ID : ", face.getID(), " ratio : ", ratio
color = scalarMap.to_rgba(ratio)
#print face.getZCentralised(), alpha_fac
#ax.add_collection3d(arrow(xcen-0.5,ycen-0.5,zcen-0.5,xcen+0.5,ycen+0.5,zcen+0.5))
pc = Poly3DCollection(verts,
alpha=alpha,
facecolor=color,
linewidths=1,
zorder=0)
pc.set_edgecolor('k')
ax.add_collection3d(pc)
ax.scatter(xcenarray[-1], ycenarray[-1], zcenarray[-1], c='r')
face = faces.next()
#if face.getID() == 1: break
#plt.clf()
for i in range(len(X)):
veclength = np.sqrt((U[i])**2 + (V[i])**2 + (W[i])**2)
#print " veclength : ", veclength, (eigenvalue[i]/maxEigenValue)
veclength *= (eigenvalue[i] / maxEigenValue)
if veclength <= 0:
colorvec = 'r'
else:
colorvec = 'k'
ax.quiver(X[i],
Y[i],
Z[i],
U[i],
V[i],
W[i],
color=colorvec,
length=veclength,
pivot='tail',
zorder=-1)
#ax.quiver(X[i], Y[i], Z[i], U[i], V[i], W[i],color='k',pivot='tail',zorder=4)# for older matplotlib
scalarMap._A = []
cbar_ax = fig.add_axes([0.873, 0.2, 0.04, 0.55])
#clrbar = plt.colorbar(scalarMap,shrink=0.5, aspect=10)
clrbar = plt.colorbar(
scalarMap, cax=cbar_ax) #,orientation='horizontal',cax = cbar_ax)
clrbar.set_label("Magnitude of Stress Anisotrophy", fontsize=18)
clrbar.ax.tick_params(labelsize=14)
#ax.set_title("Time %d : Anisotrophy of Strain : Max %.4f Min %.4f"%(step,maxEigenValueRatio,minEigenValueRatio), fontsize = 20)
#print xcenarray-0.5
#plt.close("all")
ax.view_init(azim=azim, elev=elev)
if save:
saveDirectory = "strainFigures_u%02d_v%02d" % (
azim, elev) + r"/stressSurface"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
plt.savefig(saveDirectory + r"/strainSurface_Time=%03d.png" % (step),
transparent=True)
plt.close()
return
def plotStrainEllipseSurface(cell, numOfLayer, step = None, alpha = 0.8, Length=1.0,save = False, ids = True, azim = -60, elev = 60, targetface = None):
#calculating forces, stress-matrix and strain-matrix
#cell.calculateVertexForce()
cell.calculateStressStrain()
import matplotlib.colors as colors
import matplotlib.cm as cmx
#import the libraries
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
import matplotlib.pyplot as plt
#limits of the plot
radius = (numOfLayer>1)*(np.sqrt(3.)*(numOfLayer-1)-Length)+Length#the radius of circle to be projected on
#plotting part
fig = plt.figure(frameon=False,figsize=(20,16))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
#fig.set_aspect(aspect='equal', adjustable='box')
ax = Axes3D(fig)
ax.set_xlim((-.5*radius,.5*radius))
ax.set_ylim((-.5*radius,.5*radius))
ax.set_zlim((-0.,1.*radius))
ax.axis('off')
#ax.axis('equal')
ax.xaxis.pane.set_edgecolor('black')
ax.yaxis.pane.set_edgecolor('black')
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
########################################################################
# Plotting the Cell #
########################################################################
faces = qd.CellFaceIterator(cell)
###################
face = faces.next()
while (face != None):
if face.getID() == 1:
face = faces.next()
continue
faceid = face.getID()#grabbing face id
xlist = []
ylist = []
zlist = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
ax.plot(xlist,ylist,zlist,'k')
if ids:
color = 'k'
ax.text(xmean,ymean,zmean, face.getID(),fontsize = 20, color = color)
if faceid == targetface:## if this face is the target face
color = 'r'
ax.text(xmean,ymean,zmean, face.getID(),fontsize = 20, color = color)
face = faces.next()
#if face.getID() == 1: break
#plt.clf()
##PLOTTING ELLIPSE
##PLOTTING ELLIPSE
numofface = cell.countFaces()
for i in range(2,numofface+1):
# Target Form
TFellipsepoints = getTargetFormEllipsePoints(cell,i)
verts = [zip(np.array(TFellipsepoints[0])[0],np.array(TFellipsepoints[1])[0], np.array(TFellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = 0.5,linewidths=1, facecolor = 'r',zorder = 10,label="TFM" if i == 0 else "")
pc.set_edgecolor('k')
ax.add_collection3d(pc)
# Current Form
CFellipsepoints = getCurrentFormEllipsePoints(cell,i)
verts = [zip(np.array(CFellipsepoints[0])[0],np.array(CFellipsepoints[1])[0], np.array(CFellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = 0.5,linewidths=1,zorder = 9, facecolor = 'b')
pc.set_edgecolor('k')
ax.add_collection3d(pc)
# Strain
strainellipsepoints = getStrainEllipsePoints(cell,i)
verts = [zip(np.array(strainellipsepoints[0])[0],np.array(strainellipsepoints[1])[0], np.array(strainellipsepoints[2])[0])]
pc = Poly3DCollection(verts,alpha = 0.5,linewidths=1,zorder = 11, facecolor = 'k')
pc.set_edgecolor('k')
ax.add_collection3d(pc)
ax.view_init(azim = azim,elev=elev)
scatter1_proxy = mpl.lines.Line2D([0],[0], linestyle="none", c='r', marker = 's',ms=20)
scatter2_proxy = mpl.lines.Line2D([0],[0], linestyle="none", c='b', marker = 's',ms=20)
scatter3_proxy = mpl.lines.Line2D([0],[0], linestyle="none", c='k', marker = 's',ms=20)
ax.legend([scatter1_proxy, scatter2_proxy,scatter3_proxy], ['Target Form', 'Current Form',"Strain"], numpoints = 1,loc = 0)
plt.suptitle("Step =%03d"%step,fontsize = 30)
### Saving
if save:
saveDirectory = "strainFigures"
import os
if not os.path.exists(saveDirectory):
os.makedirs(saveDirectory)
plt.savefig(saveDirectory+r"/strainEllipse_Time=%03d.png"%(step))
plt.close()
return
def plotFaceAreaDerivative(faceAreaDerivativePlot,cell,dAreaCellDict,targetid,colormap = 'cool',alpha = 0.8,
azim = -60, elev = 50):
###############################################################
# Average area growth rate
###############################################################
if targetid:
faceidarray = getNeighbourFaces(cell,targetid)
else:
faceidarray = []
averagedDArea = {}
faces = qd.CellFaceIterator(cell)
face = faces.next()
minMagnitude = 0.
maxMagnitude = 0.
while (face != None):
if ((face.getID()==1) or (face.getID() in faceidarray)):
face = faces.next()
continue
averagedDArea[face.getID()] = np.mean(dAreaCellDict[face.getID()])
if averagedDArea[face.getID()] > maxMagnitude:
maxMagnitude = averagedDArea[face.getID()]
elif averagedDArea[face.getID()] < minMagnitude:
minMagnitude = averagedDArea[face.getID()]
###########################################################
face = faces.next()
###############################################################
# Plotting the Cell #
##############################################################
jet = cm = plt.get_cmap(colormap)
cNorm = colors.Normalize(vmin=minMagnitude, vmax=maxMagnitude)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
#########################################################
faces = qd.CellFaceIterator(cell)
face = faces.next()
while (face != None):
if face.getID()==1:
face = faces.next()
continue
faceid = face.getID()#grabbing face id
xlist = []
ylist = []
zlist = []
xproj = []
yproj = []
zproj = []
#print "== Face ID : ", faceid, "=="
xmean = face.getXCentralised()
ymean = face.getYCentralised()
zmean = face.getZCentralised()
edges = qd.FaceEdgeIterator(face)
edge = edges.next()
while edge != None:
####grabbing the origin of edge####
#centralised coordiante
vertex = edge.Org()
#print vertex.getID()
xCoord1 = vertex.getXcoordinate()
yCoord1 = vertex.getYcoordinate()
zCoord1 = vertex.getZcoordinate()
xlist.append(xCoord1)
ylist.append(yCoord1)
zlist.append(zCoord1)
edge = edges.next()
xlist.append(xlist[0])
ylist.append(ylist[0])
zlist.append(zlist[0])
verts = [zip(xlist, ylist,zlist)]
########################################################################################
if face.getID() in faceidarray:
color = 'w'
else:
color = scalarMap.to_rgba(averagedDArea[face.getID()])
#print face.getZCentralised(), alpha_fac
#ax.add_collection3d(arrow(xcen-0.5,ycen-0.5,zcen-0.5,xcen+0.5,ycen+0.5,zcen+0.5))
pc = Poly3DCollection(verts,alpha = alpha,facecolor = color,linewidths=1,zorder=0)
pc.set_edgecolor('k')
faceAreaDerivativePlot.add_collection3d(pc)
#faceAreaDerivativePlot.scatter(xcenarray[-1], ycenarray[-1],zcenarray[-1], 'o',c='r')
#ax.text(xcenarray[-1], ycenarray[-1],zcenarray[-1], face.getID())
face = faces.next()
########################################################################################
scalarMap._A = []
clrbar1 = plt.colorbar(scalarMap, ax=faceAreaDerivativePlot,shrink = 0.5,aspect = 10,ticks=np.linspace(minMagnitude,maxMagnitude,3))
clrbar1.set_label(r"Area Growth Rate")
faceAreaDerivativePlot.view_init(azim = azim, elev = elev)
#######################################################
return
