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