def getRadialOrthoradialDict(cell,targetid, large = False): primordiafacelist= sf.getSeparatePrimordiaBoundaryFaceList(cell, targetid, large=large) orthoradialDict = {} radialDict = {} targetface = sf.getFace(cell,targetid) targetcentroid = np.array([targetface.getXCentralised(), targetface.getYCentralised(),targetface.getZCentralised()]) ############################################################ for listiter in range(len(primordiafacelist)): facelist = primordiafacelist[listiter] ######################################################## for count in range(len(facelist)): face = facelist[count] #nextface = facelist[(count+1)%len(facelist)] normal = face.getNormal() normalvec = np.array([qd.doublearray_getitem(normal,0), qd.doublearray_getitem(normal,1), qd.doublearray_getitem(normal,2)]) ######################################################## facecentroid = np.array([face.getXCentralised(), face.getYCentralised(),face.getZCentralised()]) #Calculating direction Vector to primordia centroid direcvec = np.subtract(targetcentroid,facecentroid) direcvec = direcvec/np.linalg.norm(direcvec) #Radial Vec to on-plane unitvector radialvec = direcvec - normalvec*(np.dot(direcvec,normalvec)) radialvec = radialvec/np.linalg.norm(radialvec) ######################################################## crossvec = np.cross(radialvec,normalvec) crossvec = crossvec/np.linalg.norm(crossvec) orthoradialDict[face.getID()] = crossvec radialDict[face.getID()]= radialvec return radialDict,orthoradialDict
def getPrimordiaHeight(cell, targetid): ################################################################### def addMeanVertex(vertex,meanx,meany,meanz): meanx += vertex.getXcoordinate() meany += vertex.getYcoordinate() meanz += vertex.getZcoordinate() return meanx,meany,meanz ######################################################################## # Getting the primordial boundary ######################################################################## facetarget = sf.getFace(cell, targetid) ########################################## # Vertex on primordial boundary ########################################## vertexList = sf.getPrimordiaBoundaryVertexList(cell, targetid) vertexNum = len(vertexList) #################################################### # Calculation of primordial height starts here # This is for smaller primordia #################################################### meanx = 0. meany = 0. meanz = 0. for vert in vertexList:#while edge.Dest().getID() != targetedge.Dest().getID(): meanx,meany,meanz = addMeanVertex(vert,meanx,meany,meanz) ###################################### targetx = facetarget.getXCentralised() targety = facetarget.getYCentralised() targetz = facetarget.getZCentralised() meanx /= vertexNum meany /= vertexNum meanz /= vertexNum height = np.sqrt((meanx-targetx)**2+(meany-targety)**2+(meanz-targetz)**2) ###################################### return height
def getGrowthRatio(numOfLayer, targetid, endStep, startStep=1, stepsize=5): if not os.path.isfile("qdObject_step=001.obj"): return [0., 0., 0., 0., 0., 0., 0., 0., 0.] cell = sf.loadCellFromFile(1) ######################################################################## meanprimordiaArray = [] meanrestArray = [] timeArray = [] ######################################################################## fitlen = 50 finalstep = startStep + stepsize * fitlen for step in range(startStep, finalstep, stepsize): ######################################################################## if not os.path.isfile( "qdObject_step=%03d.obj" % step): #check if file exists break cell = sf.loadCellFromFile(step) ################################################ primordiafacelist = sf.getPrimordiaFaces(cell, targetid, large=False) primordiaarea = 0. for face in primordiafacelist: primordiaarea += face.getAreaOfFace() ################################################ tissueSurfaceArea = sf.getSurfaceArea(cell) ################################################ primordialface = sf.getFace(cell, targetid) restoftissuearea = tissueSurfaceArea - primordiaarea ################################################ numOfPrimordialcell = len(primordiafacelist) numOfrestofcell = cell.countFaces() - 1 - numOfPrimordialcell ################################################ meanprimordiafacearea = primordiaarea / numOfPrimordialcell meanrestoftissuefacearea = restoftissuearea / (numOfrestofcell) ################################################ meanprimordiaArray.append(meanprimordiafacearea) meanrestArray.append(meanrestoftissuefacearea) timeArray.append(step - 1) ################################################ logfastarea = np.log(meanprimordiaArray) logslowarea = np.log(meanrestArray) ################################################ fastareafit, m = sop.curve_fit( fitLinFunc, timeArray[:fitlen], logfastarea[:fitlen], bounds=([-np.inf, logfastarea[0] - 0.000001], [+np.inf, logfastarea[0]])) slowareafit, m = sop.curve_fit( fitLinFunc, timeArray[:fitlen], logslowarea[:fitlen], bounds=([-np.inf, logslowarea[0] - 0.000001], [+np.inf, logslowarea[0]])) ################################################ return fastareafit[0] / slowareafit[0]
def plotFeedbackCorrection(targetid, targetsurfacearea,endStep = 2000, startStep=1,stepsize= 20,maxarea = None, areastep = 10,resetids = False, saveName = None): import numpy as np import matplotlib.pyplot as plt import os ######################################################################## # faceidarray for Primordia if not os.path.isfile("qdObject_step=001.obj"): return [0.,0.,0.,0.,0.,0.,0.,0.,0.] ######################################################################## # getting the time step for computation ######################################################################## step,tissueSurfaceArea = sf.getTimeStep(targetsurfacearea, endStep, startStep, stepsize = stepsize,resetids = resetids) ####################################################################### # Starting the Calculation ####################################################################### cell = sf.loadCellFromFile(step,resetids = resetids)#loading cell ####################################################################### targetface = sf.getFace(cell, targetid)#getting top priomrdial face cell.calculateStressStrain()#calculating stress and strain cell.setRadialOrthoradialVector(targetface)#setting the rad/orthorad vectors ####################################################################### # calculating the rad/orthorad Component of Correction terms ####################################################################### cell.setRadialOrthoradialFeedbackCorrection() cell.setRadialOrthoradialStress() cell.setPrincipalDeformationVector() cell.setPrincipalDeformationFeedbackCorrection() ####################################################################### # Plotting ####################################################################### sf.plotRadialOrthoradialFeedbackCorrectionSurface(cell, numOfLayer, azim = -60, elev = 60, name =saveName+"_feedbackcorrection_radialOrthoradial") sf.plotTracePrincipalDeformationFeedbackCorrectionSurface(cell,numOfLayer, azim = -60, elev = 60, name =saveName+"_feedbackcorrection_trace") sf.plotPrincipalDeformationFeedbackCorrectionSurface(cell, numOfLayer, azim = -60, elev = 60, name =saveName+"_feedbackcorrection_principalDeformation") sf.plotStressSurface(cell, numOfLayer, azim = -60, elev = 60, name =saveName+"_stressSurface_principal") return
def calculatePrimiordiaHeight(cell,targetid,large = False): # getting the vertexlist of primiordia boundary vertexlist = sf.getPrimordiaBoundaryVertexList(cell,targetid)#, large = large) vertexNum = len(vertexlist) meanx, meany, meanz = 0.,0.,0. for vertex in vertexlist: meanx += vertex.getXcoordinate() meany += vertex.getYcoordinate() meanz += vertex.getZcoordinate() meanx /= vertexNum meany /= vertexNum meanz /= vertexNum ########################################################################## facetarget = sf.getFace(cell,targetid) ##################################### targetx = facetarget.getXCentralised() targety = facetarget.getYCentralised() targetz = facetarget.getZCentralised() ##################################### height = np.sqrt((meanx-targetx)**2+(meany-targety)**2+(meanz-targetz)**2) ##################################### return height
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
def getGrowthRateStress(numOfLayer, endStep, eta, startStep=0, stepsize=1, maxarea=None, areastep=20, startarea=None, endarea=850, resetids=False): import numpy as np import matplotlib.pyplot as plt import os ######################################################################## # faceidarray for Primordia if not os.path.isfile("qdObject_step=001.obj"): return [0., 0., 0., 0., 0., 0., 0., 0., 0.] cell = sf.loadCellFromFile(1) initialTissueSurfaceArea = sf.getSurfaceArea(cell) ####################################################################### topFaceID = 3 * numOfLayer * ( numOfLayer - 1) + 2 #the id of cell at the top of the dome ####################################################################### # Starting the Calculation ###################################################################### ####################################################################### laststep = 1 plotargs = { "markersize": 10, "capsize": 10, "elinewidth": 3, "markeredgewidth": 2 } ####################################################################### heightArray = [] tissueSurfaceAreaArray = [] tissueSurfaceAreaArray2 = [] timeArray = [] timeArray2 = [] dhdAArray = [] volumeArray = [] radiusMeanArray = [] radiusVarArray = [] topdistance = [] ################################################################ absStressDict = {} stressRadialDict = {} stressOrthoradialDict = {} growthRateDict = {} tipDistanceDict = {} dictArray = [ absStressDict, stressRadialDict, stressOrthoradialDict, growthRateDict, tipDistanceDict ] ################################################### if not startarea: #no startarea given startarea = int(initialTissueSurfaceArea) ################################################### listsurfacearea = np.linspace(startarea, endarea, 15) for steparea in listsurfacearea: step, tissueSurfaceArea = getTimeStep(steparea, endStep, laststep, stepsize=10) step2, tissueSurfaceArea2 = getTimeStep(steparea + areastep, endStep, step, stepsize=10) if step == step2: break ######################################################################## if not (os.path.isfile("qdObject_step=%03d.obj" % step) or os.path.isfile( "qdObject_step=%03d.obj" % step2)): #check if file exists break cell = sf.loadCellFromFile(step, resetids=resetids) cell2 = sf.loadCellFromFile(step2, resetids=resetids) ################################################ topFace = sf.getFace(cell2, topFaceID) ################################################ cell2.calculateStressStrain() cell2.setRadialOrthoradialVector(topFace) cell2.setRadialOrthoradialStress() ################################################ dTissueSurfaceArea = tissueSurfaceArea2 - tissueSurfaceArea ################################################ #computing the cell growth rate ################################################ faces = qd.CellFaceIterator(cell2) face2 = faces.next() while face2 != None: faceid = face2.getID() face1 = sf.getFace(cell, faceid) ############################################ if face1 == None: absstress = np.abs(face2.getStressEigenValue1()) + np.abs( face2.getStressEigenValue2()) stressRadial = face2.getRadialStress() stressOrthoradial = face2.getOrthoradialStress() tipdistance = getFaceDistance(face2, topFace) growthrate = np.nan ############################################ addToDict(face2, dictArray, [ absstress, stressRadial, stressOrthoradial, growthrate, tipdistance ]) ############################################ face2 = faces.next() continue ############################################ facearea1 = face1.getAreaOfFace() facearea2 = face2.getAreaOfFace() ############################################ # checking if face2 has recently divided # if face divided recently, facearea is # divided in near half ############################################ if (facearea2 - facearea1) < -0.3 * facearea1: # if this is true, then face1 has # seen drastic area decrease # which would mean cell division growthrate = np.nan else: ############################################ #if no recent division ############################################ dfacearea = facearea2 - facearea1 growthrate = dfacearea / (facearea1 * dTissueSurfaceArea) ############################################ absstress = np.abs(face2.getStressEigenValue1()) + np.abs( face2.getStressEigenValue2()) stressRadial = face2.getRadialStress() stressOrthoradial = face2.getOrthoradialStress() tipdistance = getFaceDistance(face2, topFace) ############################################ addToDict(face2, dictArray, [ absstress, stressRadial, stressOrthoradial, growthrate, tipdistance ]) ############################################ face2 = faces.next() ############################################ ################################################ height = getTissueHeight(cell) heightArray.append(height) timeArray.append(step) timeArray2.append(step2) tissueSurfaceAreaArray.append(tissueSurfaceArea) tissueSurfaceAreaArray2.append(tissueSurfaceArea2) ######################################################################## print step2, tissueSurfaceArea, height ######################################################################## return [ tissueSurfaceAreaArray, tissueSurfaceAreaArray2, heightArray, timeArray, timeArray2, dictArray ]
def plotMeanStressGrowth(numOfLayer, targetid,endStep,eta, meanstress, meandilation, color,startStep=0,stepsize= 1,largerCondition =True ,maxarea = None, areastep = 20, startarea = None, endarea = 850,resetids = True): import numpy as np import matplotlib.pyplot as plt import os ######################################################################## # faceidarray for Primordia if not os.path.isfile("qdObject_step=001.obj"): return [0.,0.,0.,0.,0.,0.,0.,0.,0.] cell = sf.loadCellFromFile(1,resetids=resetids) initialTissueSurfaceArea = sf.getSurfaceArea(cell) ####################################################################### # Starting the Calculation ####################################################################### ####################################################################### laststep = 1 plotargs = {"markersize": 10, "capsize": 10,"elinewidth":3,"markeredgewidth":2} ####################################################################### orthoradialStressArray = [] radialStressArray = [] radialGrowthArray = [] orthoradialGrowthArray = [] meanstressEigenvalue1Array = [] meanstressEigenvalue2Array = [] meangrowthEigenvalue1Array = [] meangrowthEigenvalue2Array = [] meangaussianCurvatureArray = [] ################################################### # save standard deviations of the stress and growth ################################################### radialStressSDArray = [] orthoradialStressSDArray = [] radialGrowthSDArray = [] orthoradialGrowthSDArray = [] meanstressEigenvalue1SDArray = [] meanstressEigenvalue2SDArray = [] meangrowthEigenvalue1SDArray = [] meangrowthEigenvalue2SDArray = [] ################################################### tissueSurfaceAreaArray = [] primordiaAreaArray = [] boundaryAreaArray = [] heightArray = [] ################################################### if not startarea:#no startarea given startarea = int(initialTissueSurfaceArea) ################################################### listsurfacearea = np.linspace(startarea,endarea,10) #print listsurfacearea #for steparea in range(startarea, endarea, int(areastep)): for steparea in listsurfacearea: step,tissueSurfaceArea = sf.getTimeStep(steparea, endStep, laststep, stepsize = 10,resetids = resetids) ######################################################################## step2,tissueSurfaceArea2 = sf.getTimeStep(steparea+areastep, endStep, step, stepsize = 10,resetids = resetids) ######################################################################## if not os.path.isfile("qdObject_step=%03d.obj"%step):#check if file exists break cell = sf.loadCellFromFile(step,resetids=resetids) cell2 = sf.loadCellFromFile(step2,resetids=resetids) ################################################ cell.calculateStressStrain() ################################################ primordialface = sf.getFace(cell, targetid) ################################################ cell.setRadialOrthoradialVector(primordialface) cell.setRadialOrthoradialStress() ################################################ sf.calculateDilation(cell,cell2) ######################################################################## # Starting the Calculation of mean growth and mean stress on boundary ######################################################################## # mean stress ######################################################################## faceList = sf.getPrimordiaBoundaryFaceList(cell,targetid,large= large) primordiafacelist = sf.getPrimordiaFaces(cell, targetid, large = False) primordiaarea = 0. for face in primordiafacelist: primordiaarea += face.getAreaOfFace() ###################################################### #radialDict, orthoradialDict = getRadialOrthoradialDict(cell,targetid,large = large) ###################################################### radialStress = [] orthoradialStress = [] radialGrowth = [] orthoradialGrowth = [] stressEigenvalue1Array = [] stressEigenvalue2Array = [] growthEigenvalue1Array = [] growthEigenvalue2Array = [] gaussianCurvatureArray = [] dTissueSurfaceArea = tissueSurfaceArea2-tissueSurfaceArea boundaryarea = 0. for face in faceList: boundaryarea += face.getAreaOfFace() ####################################################### radstress, orthstress,stresseigenvalue1, stresseigenvalue2 = getRadialOrthoradialStress(face) radGrowth, orthGrowth, growtheigenvalue1, growtheigenvalue2 = getRadialOrthoradialGrowth(face) ####################################################### radialStress.append(radstress) orthoradialStress.append(orthstress) radialGrowth.append(radGrowth) orthoradialGrowth.append(orthGrowth) stressEigenvalue1Array.append(stresseigenvalue1) stressEigenvalue2Array.append(stresseigenvalue2) growthEigenvalue1Array.append(growtheigenvalue1) growthEigenvalue2Array.append(growtheigenvalue2) gaussianCurvatureArray.append(sf.getFaceWeightedGaussianCurvature(face)) ###################################################### radialStressArray.append(np.mean(radialStress)) orthoradialStressArray.append(np.mean(orthoradialStress)) radialGrowthArray.append(np.mean(radialGrowth)) orthoradialGrowthArray.append(np.mean(orthoradialGrowth)) tissueSurfaceAreaArray.append(tissueSurfaceArea) primordiaAreaArray.append(primordiaarea) boundaryAreaArray.append(boundaryarea) ###################################################### height = getPrimordiaHeight(cell,targetid) heightArray.append(height) ###################################################### meanstressEigenvalue1Array.append(np.mean(stressEigenvalue1Array)) meanstressEigenvalue2Array.append(np.mean(stressEigenvalue2Array)) meangrowthEigenvalue1Array.append(np.mean(growthEigenvalue1Array)) meangrowthEigenvalue2Array.append(np.mean(growthEigenvalue2Array)) meangaussianCurvatureArray.append(np.mean(gaussianCurvatureArray)) ####################################################### # calculating the standard deviation ####################################################### meanstressEigenvalue1SDArray.append(np.std(stressEigenvalue1Array)) meanstressEigenvalue2SDArray.append(np.std(stressEigenvalue2Array)) meangrowthEigenvalue1SDArray.append(np.std(growthEigenvalue1Array)) meangrowthEigenvalue2SDArray.append(np.std(growthEigenvalue2Array)) radialStressSDArray.append(np.std(radialStress)) orthoradialStressSDArray.append(np.std(orthoradialStress)) radialGrowthSDArray.append(np.std(radialGrowth)) orthoradialGrowthSDArray.append(np.std(orthoradialGrowth)) #meanstress.errorbar(tissueSurfaceArea, np.mean(radialStress), # yerr = np.std(radialStress)/float(len(radialStress)),fmt='o',label = r":$\sigma_{r}$",c=color,**plotargs) #meanstress.errorbar(tissueSurfaceArea, np.mean(orthoradialStress), # yerr = np.std(orthoradialStress)/float(len(orthoradialStress)),fmt='<',label = r":$\sigma_{o}$",c=color,**plotargs) ######################################################################## # mean dilation ######################################################################## #meandilation.errorbar(tissueSurfaceArea, np.mean(radialGrowth), # yerr = np.std(radialGrowth)/float(len(radialGrowth)),fmt='o',label = r":$g_{r}$",c=color,**plotargs) #meandilation.errorbar(tissueSurfaceArea, np.mean(orthoradialGrowth), # yerr = np.std(orthoradialGrowth)/float(len(orthoradialGrowth)),fmt='<',label = r":$g_{o}$",c=color,**plotargs) ######################################################################## laststep = step ######################################################################## print tissueSurfaceArea, tissueSurfaceArea2,dTissueSurfaceArea, step , step2 ######################################################################## return [tissueSurfaceAreaArray, radialStressArray, orthoradialStressArray, radialGrowthArray, orthoradialGrowthArray, primordiaAreaArray, heightArray, meanstressEigenvalue1Array, meanstressEigenvalue2Array, meangrowthEigenvalue1Array, meangrowthEigenvalue2Array, boundaryAreaArray, radialStressSDArray, orthoradialStressSDArray, radialGrowthSDArray, orthoradialGrowthSDArray, meanstressEigenvalue1SDArray, meanstressEigenvalue2SDArray, meangrowthEigenvalue1SDArray, meangrowthEigenvalue2SDArray, meangaussianCurvatureArray ]
def getPrimordiaBoundaryVertexList(cell, targetface, large=False): ######################################################## """ Get a list of all vertices arround a primordia targetid : center of primordia large : if true, large primordia is calculated for (2 layers) if false, small primordia (1 layer) """ face = sf.getFace(cell, targetface) edge = face.getEdge() vertexList = [] ######################################################## # tracing the primordial boundary ######################################################## if large: ######################################################### # Larger Proimordia ######################################################### for _ in range(2): edge = edge.Rprev() ##################### for _ in range(3): edge = edge.Lnext() #################################################### # listing Primordia vertex starts here #################################################### for _ in range(6): edge = edge.Rprev() vertexList.append(edge.Dest()) ##################### for _ in range(2): edge = edge.Lnext() vertexList.append(edge.Dest()) ##################### edge = edge.Rprev() vertexList.append(edge.Dest()) ##################### edge = edge.Lnext() vertexList.append(edge.Dest()) else: ######################################################### # Smaller Proimordia ######################################################### for _ in range(1): edge = edge.Rprev() ############################################################### # listing Primordia vertex starts here ############################################################### for _ in range(3): edge = edge.Lnext() vertexList.append(edge.Dest()) ##################### for _ in range(5): edge = edge.Rprev() vertexList.append(edge.Dest()) #################### edge = edge.Lnext() vertexList.append(edge.Dest()) #################### edge = edge.Lnext() vertexList.append(edge.Dest()) #################### return vertexList
def plotMinGaussianCurvaturePrimodiaHeight(numOfLayer, targetid,endStep,eta, mincurvatureplot, heightplot,ax3,ax4,ax5,ax6,ax7, color,startStep=0,stepsize= 1,largerCondition = False,maxarea = None,resetids = True): import numpy as np import matplotlib.pyplot as plt import os ######################################################################## # faceidarray for Primordia if not os.path.isfile("qdObject_step=000.obj"): return [0.,0.,0.,0.,0.,0.,0.,0.,0.] cell = sf.loadCellFromFile(0,resetids = resetids) faceList = sf.getPrimordiaFaces(cell,targetid, large = largerCondition) faceidarray = [xface.getID() for xface in faceList] primordialFaceNum = len(faceList) slowFaceNum = cell.countFaces()-primordialFaceNum- 1. #print largerCondition, faceidarray ####################################################################### # Checking if the files exists if not going to step down ####################################################################### meanGaussianCurvature = [] primodialheight = [] primodialAreaArray = [] tissueSurfaceAreaArray = [] surfaceAreaRatio = [] sphericityArray = [] tissueVolumeArray = [] timestep = [] ###################################################### # Gathering face area ###################################################### m0determinantArray = [] slowarray = [] fastarray = [] ####################################################################### # Starting the Calculation ####################################################################### ##################################### #Getting initial area of primodial ##################################### if not os.path.isfile("qdObject_step=001.obj"): return [0.,0.,0.,0.,0.,0.,0.,0.,0.] cell = sf.loadCellFromFile(1,resetids = resetids) ################################# # face area data ################################# tfmdet, slowfacearea, fastfacearea,areaPrimodia = getFaceAreaData(cell,faceidarray) ################################################################## areaInitialPrimodia = areaPrimodia ####################################################################### for step in range(startStep,endStep+1,stepsize): if not os.path.isfile("qdObject_step=%03d.obj"%step):#check if file exists break cell = sf.loadCellFromFile(step,resetids = resetids) ################################# # face area data ################################# tfmdet, slowfacearea, fastfacearea,areaPrimodia = getFaceAreaData(cell,faceidarray) m0determinantArray.append(tfmdet) ################################################################################ # saving the mean area ################################################################################ slowarray.append(slowfacearea/slowFaceNum) fastarray.append(fastfacearea/primordialFaceNum) ######################################################################## # Starting the Calcuation of Primordial Height & Curvature # ######################################################################## gaussianCurvature = [] meanpointx = [] meanpointy = [] meanpointz = [] tissueSurfaceArea = sf.getSurfaceArea(cell) tissueVolume = cell.getCartesianVolume() sphericity = (np.pi**(1./3.)*(2.**(1./2.)*3*tissueVolume)**(2./3.))/(tissueSurfaceArea) ######################################################################## # Getting the primordial boundary ######################################################################## facetarget = sf.getFace(cell, targetid) ########################################## # Vertex on primordial boundary ########################################## vertexList = getPrimordiaBoundaryVertexList(cell, targetface=targetid,large = largerCondition) vertexNum = len(vertexList) #################################################### # Calculation of primordial height starts here # This is for smaller primordia #################################################### meanx = 0. meany = 0. meanz = 0. for vert in vertexList:#while edge.Dest().getID() != targetedge.Dest().getID(): meanx,meany,meanz = addMeanVertex(vert,meanx,meany,meanz) gaussianCurvature.append(vert.getGaussianCurvature()) ###################################### targetx = facetarget.getXCentralised() targety = facetarget.getYCentralised() targetz = facetarget.getZCentralised() meanx /= vertexNum meany /= vertexNum meanz /= vertexNum height = np.sqrt((meanx-targetx)**2+(meany-targety)**2+(meanz-targetz)**2) ########################################################################## primodialheight.append(height) tissueSurfaceAreaArray.append(tissueSurfaceArea) primodialAreaArray.append(areaPrimodia) surfaceAreaRatio.append((areaPrimodia/(tissueSurfaceArea))) sphericityArray.append(sphericity) meanGaussianCurvature.append(np.mean(np.array(gaussianCurvature))) tissueVolumeArray.append(tissueVolume) timestep.append(step-1.) ################################################################################# # Plotting ################################################################################# # calculating the plotlen if maxarea: plotlen = ppf.getPlotlenMaxArea(tissueSurfaceAreaArray,maxarea) #print timestep, primodialheight, meanGaussianCurvature # Min Gaussian curvature #print timestep mincurvatureplot.plot(tissueSurfaceAreaArray[:plotlen],meanGaussianCurvature[:plotlen],c=color,lw = 1.5) ################################### # Height of Primodia heightplot.plot(tissueSurfaceAreaArray[:plotlen], primodialheight[:plotlen], c=color,lw = 1.5) ################################### # primordial area vs surface area ax3.plot(tissueSurfaceAreaArray[:plotlen], primodialAreaArray[:plotlen], c = color, lw = 1.5) ################################### # surface area vs time ax4.plot(timestep[:plotlen],tissueSurfaceAreaArray[:plotlen], c = color, lw = 1.5) #print timestep, primodialheight, meanGaussianCurvature # Min Gaussian curvature #print timestep mincurvatureplot.plot(tissueSurfaceAreaArray,meanGaussianCurvature,c=color,lw = 1.5) ################################### # Height of Primodia heightplot.plot(tissueSurfaceAreaArray, primodialheight, c=color,lw = 1.5) ################################### # primordial area vs surface area ax3.plot(tissueSurfaceAreaArray, primodialAreaArray, c = color, lw = 1.5) ################################### # surface area vs time ax4.plot(timestep,tissueSurfaceAreaArray, c = color, lw = 1.5) ######################################################## #ax3.plot(primodialAreaArray,meanGaussianCurvature,c=color,lw =1.5) #ax4.plot(primodialAreaArray,primodialheight,c=color,lw = 1.5) ######################################################## #ax5.plot(surfaceAreaRatio,meanGaussianCurvature,c=color,lw =1.5) #ax6.plot(surfaceAreaRatio,primodialheight,c=color,lw = 1.5) ######################################################## #ax7.plot(timestep, sphericityArray,c=color,lw = 1.5) return [primodialheight, meanGaussianCurvature,primodialAreaArray, tissueSurfaceAreaArray,tissueVolumeArray, sphericityArray,m0determinantArray, fastarray, slowarray,timestep]
def plotPrincipalStress(numOfLayer, targetid, endStep, eta, meanstressplot, color, startStep=0, stepsize=1, largerCondition=True, maxarea=None, areastep=20, startarea=None, endarea=850): import numpy as np import matplotlib.pyplot as plt import os ######################################################################## # faceidarray for Primordia if not os.path.isfile("qdObject_step=001.obj"): return [0., 0., 0., 0., 0., 0., 0., 0., 0.] cell = sf.loadCellFromFile(1) initialTissueSurfaceArea = sf.getSurfaceArea(cell) ####################################################################### # Starting the Calculation ####################################################################### laststep = 1 plotargs = { "markersize": 10, "capsize": 10, "elinewidth": 3, "markeredgewidth": 2 } ####################################################################### tissueSurfaceAreaArray = [] meanstressEigenvalue1Array = [] meanstressEigenvalue2Array = [] heightArray = [] primordialAreaArray = [] radialStressArray = [] orthoradialStressArray = [] if not startarea: #no startarea given startarea = int(initialTissueSurfaceArea) for steparea in range(startarea, endarea, int(areastep)): step, tissueSurfaceArea = getTimeStep(steparea, endStep, laststep, stepsize=10) ######################################################################## if not os.path.isfile( "qdObject_step=%03d.obj" % step): #check if file exists break cell = sf.loadCellFromFile(step) ################################################ cell.calculateStressStrain() ################################################ primordialface = sf.getFace(cell, targetid) ################################################ cell.setRadialOrthoradialVector(primordialface) cell.setRadialOrthoradialStress() ################################################ ######################################################################## # Starting the Calculation of mean growth and mean stress on boundary ######################################################################## # mean stress ######################################################################## faceList = sf.getPrimordiaBoundaryFaceList(cell, targetid, large=large) height = getPrimordiaHeight(cell, targetid) ############################################### primordiafacelist = sf.getPrimordiaFaces(cell, targetid, large=False) primordiaarea = 0. for face in primordiafacelist: primordiaarea += face.getAreaOfFace() ###################################################### #radialDict, orthoradialDict = getRadialOrthoradialDict(cell,targetid,large = large) ###################################################### stressEigenvalue1Array = [] stressEigenvalue2Array = [] radialStress = [] orthoradialStress = [] for face in faceList: radstress = face.getRadialStress() orthstress = face.getOrthoradialStress() stresseigenvalue1 = face.getStressEigenValue1() stresseigenvalue2 = face.getStressEigenValue2() radialStress.append(radstress) orthoradialStress.append(orthstress) ####################################################### stressEigenvalue1Array.append(stresseigenvalue1) stressEigenvalue2Array.append(stresseigenvalue2) ###################################################### tissueSurfaceAreaArray.append(tissueSurfaceArea) heightArray.append(height) ###################################################### meanstressEigenvalue1Array.append(np.mean(stressEigenvalue1Array)) meanstressEigenvalue2Array.append(np.mean(stressEigenvalue2Array)) radialStressArray.append(np.mean(radialStress)) orthoradialStressArray.append(np.mean(orthoradialStress)) primordialAreaArray.append(primordiaarea) ######################################################################## laststep = step ######################################################################## return [ tissueSurfaceAreaArray, meanstressEigenvalue1Array, meanstressEigenvalue2Array, np.add(meanstressEigenvalue1Array, meanstressEigenvalue2Array), np.subtract(meanstressEigenvalue2Array, meanstressEigenvalue1Array), heightArray, primordialAreaArray, radialStressArray, orthoradialStressArray ]
def plotHeightGrowthScatter(numOfLayer, targetid, endStep, eta, stressscatter, growthscatter, stressscatter1, growthscatter1, anisotropyplot, color='r', maxeta=20, startStep=0, stepsize=1, largerCondition=True, maxarea=None, areastep=20, cloud=False, startarea=None, resetids=True, endarea=850): import numpy as np import matplotlib.pyplot as plt import os ######################################################################## # faceidarray for Primordia if not os.path.isfile("qdObject_step=001.obj"): return [0., 0., 0., 0., 0., 0., 0., 0., 0.] cell = sf.loadCellFromFile(1, resetids=resetids) initialTissueSurfaceArea = sf.getSurfaceArea(cell) ####################################################################### # Starting the Calculation ####################################################################### laststep = 1 plotargs = { "markersize": 10, "capsize": 10, "elinewidth": 3, "markeredgewidth": 2 } ####################################################################### orthoradialStressArray = [] radialStressArray = [] radialGrowthArray = [] orthoradialGrowthArray = [] tissueSurfaceAreaArray = [] primordiaAreaArray = [] heightArray = [] meanstressEigenvalue1Array = [] meanstressEigenvalue2Array = [] meangrowthEigenvalue1Array = [] meangrowthEigenvalue2Array = [] meanstressdiffarray = [] areadiffarray = [] if not startarea: #no startarea given startarea = int(initialTissueSurfaceArea) for steparea in range(startarea, endarea, int(areastep)): step, tissueSurfaceArea = getTimeStep(steparea, endStep, laststep, stepsize=5, resetids=resetids) ######################################################################## step2, tissueSurfaceArea2 = getTimeStep(steparea + areastep, endStep, step, stepsize=5, resetids=resetids) ######################################################################## if not os.path.isfile( "qdObject_step=%03d.obj" % step): #check if file exists break cell = sf.loadCellFromFile(step, resetids=resetids) cell2 = sf.loadCellFromFile(step2, resetids=resetids) ################################################ cell.calculateStressStrain() ################################################ primordialface = sf.getFace(cell, targetid) ################################################ cell.setRadialOrthoradialVector(primordialface) cell.setRadialOrthoradialStress() ################################################ sf.calculateDilation(cell, cell2) ######################################################################## # Starting the Calculation of mean growth and mean stress on boundary ######################################################################## # mean stress ######################################################################## faceList = sf.getPrimordiaBoundaryFaceList(cell, targetid, large=large) primordiafacelist = sf.getPrimordiaFaces(cell, targetid, large=False) primordiaarea = 0. for face in primordiafacelist: primordiaarea += face.getAreaOfFace() ###################################################### #radialDict, orthoradialDict = getRadialOrthoradialDict(cell,targetid,large = large) ###################################################### stressEigenvalue1Array = [] stressEigenvalue2Array = [] growthEigenvalue1Array = [] growthEigenvalue2Array = [] stressdiffarray = [] growthdiffarray = [] dTissueSurfaceArea = tissueSurfaceArea2 - tissueSurfaceArea height = getPrimordiaHeight(cell, targetid) height2 = getPrimordiaHeight(cell2, targetid) dhdA = (height2 - height) / dTissueSurfaceArea for face in faceList: radstress, orthstress, stresseigenvalue1, stresseigenvalue2 = getRadialOrthoradialStress( face) radGrowth, orthGrowth, growtheigenvalue1, growtheigenvalue2 = getRadialOrthoradialGrowth( face) stressEigenvalue1Array.append(stresseigenvalue1) stressEigenvalue2Array.append(stresseigenvalue2) growthEigenvalue1Array.append(growtheigenvalue1) growthEigenvalue2Array.append(growtheigenvalue2) stressdiffarray.append(stresseigenvalue2 - stresseigenvalue1) growthdiffarray.append(growtheigenvalue2 - growtheigenvalue1) ####################################################### # plotting ####################################################### meanstresseigen1 = np.mean(stressEigenvalue1Array) meanstresseigen2 = np.mean(stressEigenvalue2Array) meangrowtheigenvalue1 = np.mean(growthEigenvalue1Array) meangrowtheigenvalue2 = np.mean(growthEigenvalue2Array) sigma2 = max(meanstresseigen1, meanstresseigen2) sigma1 = min(meanstresseigen1, meanstresseigen2) g2 = max(meangrowtheigenvalue1, meangrowtheigenvalue2) g1 = min(meangrowtheigenvalue1, meangrowtheigenvalue2) ####################################################### stressscatter.scatter(sigma2 - sigma1, dhdA, c=color, marker='o', alpha=0.7, zorder=maxeta - eta) growthscatter.scatter(g2 - g1, dhdA, c=color, marker='o', alpha=0.7, zorder=maxeta - eta) ####################################################### stressscatter1.scatter(np.mean(stressdiffarray), dhdA, c=color, marker='o', alpha=0.7, zorder=maxeta - eta) growthscatter1.scatter(np.mean(growthdiffarray), dhdA, c=color, marker='o', alpha=0.7, zorder=maxeta - eta) ####################################################### anisotropyplot.scatter(np.mean(stressdiffarray), dhdA, c=color, marker='o', alpha=0.7, zorder=maxeta - eta) meanstressdiffarray.append(np.mean(stressdiffarray)) areadiffarray.append(dhdA) ######################################################################## laststep = step ######################################################################## print tissueSurfaceArea, tissueSurfaceArea2, dTissueSurfaceArea, step, step2 ######################################################################## if cloudCondition: points = np.vstack((meanstressdiffarray, areadiffarray)).T hull_pts = ConvexHull(points) hull_pts = points[hull_pts.vertices] hull_pts = np.vstack((hull_pts, hull_pts[0])).T interpolatex, interpolatey = interpolatedata(hull_pts) anisotropyplot.plot(interpolatex, interpolatey, c=color, ls='--', lw=2) ######################################################################## return [meanstressdiffarray, areadiffarray]
def plotMinGaussianCurvaturePrimodiaHeight(numOfLayer, targetid, endstep, fastkappa, mincurvatureplot, heightplot, color): import numpy as np import matplotlib.pyplot as plt ######################################################################## # Loading the Cell # ######################################################################## ####################################################################### # Checking if the files exists if not going to step down ####################################################################### meanGaussianCurvature = [] primodialheight = [] for step in range(1, endStep + 1): if not os.path.isfile( "qdObject_step=%03d.obj" % step): #check if file exists break cell = sf.loadCellFromFile(step) ######################################################################## # Starting the Calcuation of Curvature # ######################################################################## gaussianCurvature = [] meanpointx = [] meanpointy = [] meanpointz = [] ########## edge = getEdge(cell, 211, 210) edgenext = edge ####grabbing the origin of edge#### vertexDest = edge.Dest() meanpointx.append(vertexDest.getXcoordinate()) meanpointy.append(vertexDest.getYcoordinate()) meanpointz.append(vertexDest.getZcoordinate()) # Get the Gaussian Curvature gaussianCurvature.append(vertexDest.getGaussianCurvature()) while True: edgenext = edgenext.Rprev() vertexDest = edgenext.Dest() meanpointx.append(vertexDest.getXcoordinate()) meanpointy.append(vertexDest.getYcoordinate()) meanpointz.append(vertexDest.getZcoordinate()) gaussianCurvature.append(vertexDest.getGaussianCurvature()) ######################################################## edgenext = edgenext.Lnext() vertexDest = edgenext.Dest() meanpointx.append(vertexDest.getXcoordinate()) meanpointy.append(vertexDest.getYcoordinate()) meanpointz.append(vertexDest.getZcoordinate()) gaussianCurvature.append(vertexDest.getGaussianCurvature()) ######################################################## edgenext = edgenext.Lnext() vertexDest = edgenext.Dest() meanpointx.append(vertexDest.getXcoordinate()) meanpointy.append(vertexDest.getYcoordinate()) meanpointz.append(vertexDest.getZcoordinate()) gaussianCurvature.append(vertexDest.getGaussianCurvature()) ############################################################### edgenext = edgenext.Rprev() vertexDest = edgenext.Dest() meanpointx.append(vertexDest.getXcoordinate()) meanpointy.append(vertexDest.getYcoordinate()) meanpointz.append(vertexDest.getZcoordinate()) gaussianCurvature.append(vertexDest.getGaussianCurvature()) ######################################################## edgenext = edgenext.Lnext() vertexDest = edgenext.Dest() meanpointx.append(vertexDest.getXcoordinate()) meanpointy.append(vertexDest.getYcoordinate()) meanpointz.append(vertexDest.getZcoordinate()) gaussianCurvature.append(vertexDest.getGaussianCurvature()) ############################################################# if edgenext.Org().getID() == edge.Org().getID(): break facetarget = sf.getFace(cell, targetid) targetx = facetarget.getXCentralised() targety = facetarget.getYCentralised() targetz = facetarget.getZCentralised() meanx = np.mean(meanpointx) meany = np.mean(meanpointy) meanz = np.mean(meanpointz) height = np.sqrt((meanx - targetx)**2 + (meany - targety)**2 + (meanz - targetz)**2) ########################################################################## primodialheight.append(height) meanGaussianCurvature.append(np.mean(np.array(gaussianCurvature))) ################################################################################# # Plotting ################################################################################# timestep = range(len(primodialheight)) #print primodialheight, meanGaussianCurvature # Min Gaussian curvature mincurvatureplot.plot(timestep, meanGaussianCurvature, c=color, lw=3) ################################### # Height of Primodia heightplot.plot(timestep, primodialheight, c=color, lw=3) ######################################################## return