def __init__(self): super(GaussianPlot, self).__init__(None,None) self.poly = [[],[],[]]; self.oldGauss = None self.oldLine = [None,None,None] self.line = None self.sedimentLenght = 0.1 self.r = 0.3 self.polyMarshal = PolinomialMarshal()
def __init__(self): super(MeloshPlot, self).__init__(None, None) self.polyMarshal = PolinomialMarshal() self.x, self.y = 491, 953
class MeloshPlot(movablePoints.HandleMovablePoints): def __init__(self): super(MeloshPlot, self).__init__(None, None) self.polyMarshal = PolinomialMarshal() self.x, self.y = 491, 953 def addControlPoint(self, x, y, i): pt = super(MeloshPlot, self).addControlPoint(x, y) self.poly[i].append(pt) return pt def addPoint(self, pt, i): self.poly[i].append(pt) def getProfile(self, elipse_transform_radious): x1, y1 = self.plotSediment() x2, y2 = self.plotInterior() xp, yp = self.plotPeak() x3, y3 = self.plotEjecta() # x = np.array([x1,x2]).flatten() # y = np.array([y1,y2]).flatten() - self.yTrans x = elipse_transform_radious * np.array([x1, x2, xp, x3]).flatten() y = np.array([y1, y2, yp, y3]).flatten() # - self.yTrans return x, y def paintLeyend(self): print "leyenda" def paint(self, line, elipse_transform_radious=1.0): # print "paint" self.CADConstraints() # D2 = self.D2 # xs = self.xs # self.xs = self.xs*elipse_transform_radious # self.D2 = self.D2*elipse_transform_radious x, y = self.getProfile(elipse_transform_radious) # self.D2 = D2 # self.xs = xs # if(self.line == None): # self.line, = plt.plot(x,y,lw=2,color='blue') # else: line.set_xdata(x) line.set_ydata(y) return x, y def marshalPolynomialCrater(self): return self.polyMarshal.marshalPolynomialCrater() def marshalPolynomialCraterMock(self): return self.polyMarshal.marshalPolynomialCraterMock() def repaint(self): self.paint(self.line) def plotSediment(self): # syms hs xs ys yp_s a b c d f # e1 = hs + (xs^4)*c + (xs^3)*d == ys; # e2 = 4*c*xs^3 + 3*d*xs^2 == yp_s; # sol = solve([e1,e2],[c,d]); minX = 0 maxX = self.xs xs = self.xs ys = self.ys hs = self.hs D = 2 * self.D2 h = self.h hr = self.hr # coef = [(ys-hs)/(xs**2),0, hs] # p = np.poly1d(coef) xp = np.linspace(minX, maxX, 200) # if(hs>ys): # return xp,hs*np.ones(len(xp)) yp_s = (h + hs + hr) * (8 * xs / (D * D)) c = -(3 * hs - 3 * ys + xs * yp_s) / (xs ** 2) d = (2 * hs - 2 * ys + xs * yp_s) / (xs ** 3) if c < 0: xFlat = -2 * c / (3 * d) yFlat = hs + (c * xFlat) * xFlat + (d * xFlat) * xFlat * xFlat # xp = np.linspace(xFlat,maxX, 200) return xp, (xp <= xFlat) * yFlat + (xp > xFlat) * (hs + (c * xp) * xp + (d * xp) * xp * xp) # (2*c*xp) + (d*xp)*3*xp = 0 # c = (3*hs - 3*ys + xs*yp_s)/xs**4 # d = -(4*hs - 4*ys + xs*yp_s)/xs**3 # print "c: %f\td: %f\n"%(c,d) # print c # if(c<0): # return xp,hs*np.ones(len(xp)) # return xp, hs + (c*xp)*xp*xp*xp + (d*xp)*xp*xp return xp, hs + (c * xp) * xp + (d * xp) * xp * xp # return xp,hs + (xp*xp)*(ys-hs)/(xs**2) # p(xp) def plotInterior(self): minX = self.xs maxX = self.getPeakXMinLimit() # self.D2-self.D2/12 xs = self.xs ys = self.ys hr = self.hr hs = self.hs h = self.h D = 2 * self.D2 xp = np.linspace(minX, maxX, 200) return xp, (h + hs + hr) * ((2 * xp / D) ** 2) # (xp**2)*(ys/(xs**2))# (h+hr)*( (2*xp/D)**2) def getPeakXMinLimit(self): m = np.amax([self.xs, self.D2 - self.D2 / 12]) return m def plotPeak(self): # x_1 = self.getPeakXMinLimit() +0.0001# self.D2-self.D2/12+0.0001 # x_2 = self.D2+self.D2/12-0.0001 # a = -(2*x_1**5*y_1 + x_2**5*y_2 - x_1**6*yp_1 - x_2**6*yp_2 - 4*x_1*x_2**4*y_1 - 6*x_1**4*x_2*y_2 + 3*x_1**2*x_2**3*y_1 + 4*x_1**3*x_2**2*y_2 - 2*x_1**2*x_2**4*yp_1 + 3*x_1**3*x_2**3*yp_1 + 4*x_1**3*x_2**3*yp_2 - 3*x_1**4*x_2**2*yp_2)/((x_1 - x_2)**2*(- 2*x_1**3 + 2*x_1**2*x_2 + 2*x_1*x_2**2 - x_2**3)) # b = -(x_1*(2*x_2**5*y_1 - 2*x_2**5*y_2 + 2*x_2**6*yp_2 - 4*x_1**4*x_2*y_1 + 4*x_1**4*x_2*y_2 + x_1*x_2**5*yp_1 + 2*x_1**5*x_2*yp_1 - 3*x_1**3*x_2**3*yp_1 - 4*x_1**2*x_2**4*yp_2 + 2*x_1**4*x_2**2*yp_2))/((x_1 - x_2)**2*(- 2*x_1**3 + 2*x_1**2*x_2 + 2*x_1*x_2**2 - x_2**3)) # c = (x_1**2*x_2**2*(2*x_1**3*y_2 - 2*x_1**3*y_1 + x_2**3*y_1 - x_2**3*y_2 + x_1**4*yp_1 + x_2**4*yp_2 + x_1*x_2**3*yp_1 + 2*x_1**3*x_2*yp_2 - 2*x_1**2*x_2**2*yp_1 - 3*x_1**2*x_2**2*yp_2))/((x_1**2 - 2*x_1*x_2 + x_2**2)*(- 2*x_1**3 + 2*x_1**2*x_2 + 2*x_1*x_2**2 - x_2**3)) # d = -(x_1**3*yp_1 - x_2**3*yp_2 - x_1**2*x_2*yp_1 + x_1*x_2**2*yp_2 - 2*x_1*x_2*y_1 + 2*x_1*x_2*y_2)/((x_1 - x_2)*(- 2*x_1**3 + 2*x_1**2*x_2 + 2*x_1*x_2**2 - x_2**3)) D = self.D2 * 2 h = self.h hs = self.hs hr = self.hr x_1 = self.x_1 x_2 = self.x_2 xp2 = np.linspace(x_1, x_2, 200) # y_1 = (h+hr+hs)* ( (2*x_1/D)**2) # yp_1 = (8/(D*D))*(h+hr+hs)*x_1 # y_2 = ((hr)* (D**3) * (x_2**(-3)) )/8 +h + hs #((hr)* ((D/x_2)**3 ))/8 +h + hs # yp_2 = ((hr)* (D**3) *(-3) * (x_2**(-4)) )/8 # a = (x_1**3*y_2 - x_2**3*y_1 + 3*x_1*x_2**2*y_1 - 3*x_1**2*x_2*y_2 + x_1*x_2**3*yp_1 - x_1**3*x_2*yp_2 - x_1**2*x_2**2*yp_1 + x_1**2*x_2**2*yp_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # b = (x_1**3*yp_2 - x_2**3*yp_1 - x_1*x_2**2*yp_1 + 2*x_1**2*x_2*yp_1 - 2*x_1*x_2**2*yp_2 + x_1**2*x_2*yp_2 - 6*x_1*x_2*y_1 + 6*x_1*x_2*y_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # c = (3*x_1*y_1 - 3*x_1*y_2 + 3*x_2*y_1 - 3*x_2*y_2 - x_1**2*yp_1 - 2*x_1**2*yp_2 + 2*x_2**2*yp_1 + x_2**2*yp_2 - x_1*x_2*yp_1 + x_1*x_2*yp_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # d = -(2*y_1 - 2*y_2 - x_1*yp_1 - x_1*yp_2 + x_2*yp_1 + x_2*yp_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # coef = [(ys-hs)/(xs**2),0, hs] # p = np.poly1d(coef) # xp = np.linspace(x_1,x_2, 200) y_1 = (h + hr + hs) * ((2 * x_1 / D) ** 2) yp_1 = (8 / (D * D)) * (h + hr + hs) * x_1 yp_2 = ((hr) * (D ** 3) * (-3) * (x_2 ** (-4))) / 8 y_2 = ((hr) * (D ** 3) * (x_2 ** (-3))) / 8 + h + hs # transform to local space y_2 = y_2 - y_1 x_2 = x_2 - x_1 a = 0 b = yp_1 c = -(2 * x_2 * yp_1 - 3 * y_2 + x_2 * yp_2) / (x_2 * x_2) d = (x_2 * yp_1 - 2 * y_2 + x_2 * yp_2) / (x_2 ** 3) # print "y_1,yp_1,yp_2,y_2",y_1,yp_1,yp_2,y_2 # print "a,b,c,d : ",a,b,c,d xp_t = xp2 - x_1 yp_t = a + b * xp_t + c * (xp_t ** 2) + d * (xp_t ** 3) + y_1 # xp_t = xp_t + x_1 # yp = a + b*xp + c * (xp**2) +d * (xp ** 3) # plt.figure(2) # plt.clf() # plt.plot(xp_t,yp_t,'g^') # plt.plot(xp,yp,'r^') # plt.show() # return np.array([0]),np.array([0]) return xp2, yp_t # return xp-xp[0],yp-yp[0] # return np.concatenate((xp,xp_t)), np.concatenate( (yp,yp_t)) #a + b/(xp) + c/(xp*xp) + d*xp*xp # p(xp) # return xp, self.a + self.b*xp_t + self.c * (xp_t**2) +self.d * (xp_t ** 3) #a + b/(xp) + c/(xp*xp) + d*xp*xp # p(xp) def plotEjecta(self): minX = self.D2 + self.D2 / 12 maxX = self.D2 + 200 + 300 D = self.D2 * 2 h = self.h hr = self.hr hs = self.hs xp = np.linspace(minX, maxX, 200) return xp, ((hr) * ((D / xp) ** 3)) / 8 + h + hs # hr*( (2*xp/D)**(-3)) + h def setParameters(self, hs, D2, hr, aRepose, lemp, lema): self.hs = hs self.D2 = D2 self.hr = hr self.aRepose = aRepose self.lema = lema self.lemp = lemp # self.x,self.y = 491,953 def setLocation(self, crater): self.x, self.y = crater.x, crater.y print "new loc ", self.x, self.y def setParametersCrater(self, c): self.polyMarshal.popFloatStack() self.hs = c.hs self.D2 = c.D2 self.hr = c.hr self.aRepose = c.aRepose self.x = c.x self.y = c.y self.lema = c.lema self.lemp = c.lemp # self.curvature = curvature # def setParametersCrater(self,crater): # self.sedimentLenght = crater.sediment # self.r = crater.w # self.hs = crater.h # self.sigma = crater.sigma # self.curvature = crater.curvature def CADConstraints(self): D = self.D2 * 2 hr = self.hr hs = self.hs if D < 0.00001: return # from http://www.lpi.usra.edu/meetings/lpsc2013/pdf/1304.pdf # Smp (N = 3693) d = 0.165D1.094 d = 0.073D1.311 d = 0.011D1.992 # 0.073D1.311 # ha = 0.073*(D**1.311) # H.-J. Hsu1 and N. G. Barlow1, INVESTIGATION OF THE RELATIONSHIP OF CRATER DEPTHS AND DIAMETERS IN SELECTED REGIONS OF MARS, Department of Physics and Astronomy, Northern Arizona University, NAU Box 6010, Flagstaff, Arizona 2013 # RV to calculate true ht and Dt ht = 0.1624 * D + 0.0065 # *1000 ht = ht / 0.8 Dt = D ha = ht - hs self.yTrans = 0 # hs+ha # print "hs "+str(hs) # print "ht+hr "+str(ht+hr) err = ht + hr - hs # print "err "+str( (1.30/err)**2 ) # print ht*0.8 # print ha,D # print hs,ha,hr,ht # # *0.8 # true depth calcuate aparent h, based on apparent D self.h = ha # - self.hr + self.hs self.ha = ha self.xs = np.tan((np.pi / 180) * self.aRepose) * (D ** 2) / (8 * (ha + hr + hs)) self.ys = (ha + hr + hs) * ((2 * self.xs / D) ** 2) # aRepose = np.atan( xs * (8 * (ha+hr+hs) )/ (D**2) )*(180.0/np.pi) if hs > self.ys: self.ys = hs self.xs = np.sqrt(self.ys / (hs + hr + ha)) * D / 2.0 # self.ys = hs+self.aRepose # self.xs = np.sqrt(self.ys/(hs+hr+ha) )*D/2.0 # np.tan(self.aRepose)*(D**2) / (8 * (ha+hr) ) # self.ys = (ha+self.hr) * ((2*self.xs/D)**2) # (ha+self.hr) * ((2*self.xs/D)**2) # self.aRepose+hs # self.aRepose # (ha+self.hr) * ((2*self.xs/D)**2) # np.sqrt(self.ys/(ha+hr+ha) )*D/2.0 # np.sqrt(self.ys/(ha+hr) )*D/2.0 # np.tan(self.aRepose)*(D**2) / (8 * (h+hr) ) # print self.xs,self.ys h = self.h x_1 = self.getPeakXMinLimit() + 0.0001 # self.D2-self.D2/12+0.0001 x_2 = self.D2 + self.D2 / 12 - 0.0001 # y_1 = (h+hr+hs)* ( (2*x_1/D)**2) # yp_1 = (8/(D*D))*(h+hr+hs)*x_1 # #((hr)* ((D/x_2)**3 ))/8 +h + hs # yp_2 = ((hr)* (D**3) *(-3) * (x_2**(-4)) )/8 # y_2 = ((hr)* (D**3) * (x_2**(-3)) )/8 +h + hs # y_2 = (y_2 - y_1) # x_2 = (x_2 - x_1) # self.a = (x_1**3*y_2 - x_2**3*y_1 + 3*x_1*x_2**2*y_1 - 3*x_1**2*x_2*y_2 + x_1*x_2**3*yp_1 - x_1**3*x_2*yp_2 - x_1**2*x_2**2*yp_1 + x_1**2*x_2**2*yp_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # self.b = (x_1**3*yp_2 - x_2**3*yp_1 - x_1*x_2**2*yp_1 + 2*x_1**2*x_2*yp_1 - 2*x_1*x_2**2*yp_2 + x_1**2*x_2*yp_2 - 6*x_1*x_2*y_1 + 6*x_1*x_2*y_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # self.c = (3*x_1*y_1 - 3*x_1*y_2 + 3*x_2*y_1 - 3*x_2*y_2 - x_1**2*yp_1 - 2*x_1**2*yp_2 + 2*x_2**2*yp_1 + x_2**2*yp_2 - x_1*x_2*yp_1 + x_1*x_2*yp_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # self.d = -(2*y_1 - 2*y_2 - x_1*yp_1 - x_1*yp_2 + x_2*yp_1 + x_2*yp_2)/((x_1 - x_2)*(x_1**2 - 2*x_1*x_2 + x_2**2)) # x_2 = x_2 + x_1 # self.a = 0 # self.b = yp_1 # self.c = -(2*x_2*yp_1 - 3*y_2 + x_2*yp_2)/(x_2*x_2) # self.d = (x_2*yp_1 - 2*y_2 + x_2*yp_2)/(x_2**3) self.x_1 = x_1 self.x_2 = x_2 # self.y_1 = y_1 # e1 = (x_2)*yp_1 + (x_2^2)*c + (x_2^3)*d == y_2; # e2 = yp_1 + 2*x_2*c + 3*d*x_2^2 == yp_2; # self.peakXMin = x_1 # print "xs,ys : "+str(self.xs)+", "+str(self.ys) # push parameters # print "\tX --> "+str(self.x)+" size "+str(len(self.polyMarshal.floatStack)) self.polyMarshal.pushFloat(self.x) self.polyMarshal.pushFloat(self.y) self.polyMarshal.pushFloat(D) self.polyMarshal.pushFloat(self.hs) self.polyMarshal.pushFloat(self.h) # ha self.polyMarshal.pushFloat(self.hr) self.polyMarshal.pushFloat(self.xs) self.polyMarshal.pushFloat(self.ys) self.polyMarshal.pushFloat(err) self.polyMarshal.pushFloat(self.lemp) self.polyMarshal.pushFloat(self.lema) self.polyMarshal.pushFloat(self.x_1) self.polyMarshal.pushFloat(self.x_2) self.polyMarshal.pushFloat(self.aRepose) self.polyMarshal.pushFloat(self.ha) self.polyMarshal.pushFloat(self.x_1)
class GaussianPlot(movablePoints.HandleMovablePoints): def __init__(self): super(GaussianPlot, self).__init__(None,None) self.poly = [[],[],[]]; self.oldGauss = None self.oldLine = [None,None,None] self.line = None self.sedimentLenght = 0.1 self.r = 0.3 self.polyMarshal = PolinomialMarshal() def addControlPoint(self,x,y,i): pt = super(GaussianPlot, self).addControlPoint(x,y) self.poly[i].append(pt) return pt def addPoint(self,pt,i): self.poly[i].append(pt) def paint(self,line): self.CADConstraints() # t = np.arange(0,1.699, 0.1) x1,y1 = self.plotPolynomial(0) x2,y2 = self.plotPolynomial(1) x3,y3 = self.plotGaussian() x = np.array([x1,x2,x3]).flatten() y = np.array([y1,y2,y3]).flatten() if(self.line == None): self.line, = plt.plot(x,y,lw=2,color='blue') else: line.set_xdata(x) line.set_ydata(y) def marshalPolynomialCrater(self): return self.polyMarshal.marshalPolynomialCrater() def repaint(self): self.paint(self.line) # self.plotPolynomial(2) def plotPolynomial(self,iPoly): p = self.poly[iPoly] ptX = [] ptY = [] n = len(p) c0 = p[0] c1 = p[n-1] # add dinamyc points for i in range(0,n): c = p[i] ptX.append(c.x) ptY.append(c.y) # add point reflexion with c0 axis # print "c.x "+str(c.x) + str(c0.x) if(-c.x+c0.x != 0): ptX.append(-c.x+2*c0.x) ptY.append(c.y) coef = np.polyfit(np.array(ptX),np.array(ptY),3) p = np.poly1d(coef) xp = np.linspace(c0.x, c1.x, 100) self.polyMarshal.pushPolynomial(c0.x, c1.x,coef) return xp,p(xp) # self.oldLine[iPoly].set_ydata(p(xp)) # movablePoints.removeLine(self.oldLine[iPoly]) # self.oldLine[iPoly] = plt.plot( xp,p(xp),'r') def plotGaussian(self): mean = self.mean sigma = self.sigma hs = self.hs #0.025 xp = np.linspace(mean, 2, 100) a = 1/(sigma*np.sqrt(2*np.pi)) # Calculate the max y value of the gaussian # My = a # print a # print np.exp( -(0.0)**2/(2.0*sigma**2) ) yp = hs*np.exp(-(xp-mean)**2/(2.0*sigma**2) ) + self.h - hs # yp = 1/ (1+np.exp(-( -xp*10+10) ) ) # print yp self.polyMarshal.pushGaussian(mean, 2.0,mean,sigma,self.h,hs) #movablePoints.removeLine(self.oldGauss) #self.oldGauss = plt.plot( xp,yp,'r') # print "gauss Down" return xp,yp def addGaussian(self,h,sigma): self.h = h self.sigma = sigma # def addEvents(self): # fig.canvas.mpl_connect('key_press_event', press) def keyPressEvents(self,e): print "KeySon: "+e.key if(e.key == 'x'): self.sigma +=0.01 elif(e.key=='z'): self.sigma -=0.01 elif(e.key == 'q'): self.r +=0.01 elif(e.key=='w'): self.r -=0.01 elif(e.key == 'e'): self.sedimentLenght +=0.01 elif(e.key=='r'): self.sedimentLenght -=0.01 print self.sigma print self.r # repaint self.repaint() def setParameters(self,sediment,w,h,sigma): self.sedimentLenght = sediment self.r = w self.hs = h self.sigma = sigma def CADConstraints(self): k = 0.047 j = 1.284 sediment = self.poly[0] sedimentLenght = self.sedimentLenght interiorCurve = self.poly[1] lowerPt = sediment[0] sedimentEnd = sediment[1] sedimentEnd.setCenter(sedimentLenght,sedimentEnd.y) n = len(interiorCurve) topPt = interiorCurve[n-1] # r = topPt.x r = self.r h = 2*k*r**j +lowerPt.y # set parameters for gaussian self.h = h self.mean = r self.base = lowerPt.y topPt.setCenter(r,h)