def __init__(self,hue,sat,val): """Each matrix must be the same size, with values in the range 0.0 to 1.0.""" shape = hue.shape # Assumed same as sat.shape and val.shape rmat = Numeric.zeros(shape,Numeric.Float) gmat = Numeric.zeros(shape,Numeric.Float) bmat = Numeric.zeros(shape,Numeric.Float) # Note: should someday file a feature request for PIL for them # to accept an image of type 'HSV', so that they will do this # conversion themselves, without us needing an explicit loop # here. That should speed this up. ch = hue.clip(0.0,1.0) cs = sat.clip(0.0,1.0) cv = val.clip(0.0,1.0) for i in range(shape[0]): for j in range(shape[1]): r,g,b = hsv_to_rgb(ch[i,j],cs[i,j],cv[i,j]) rmat[i,j] = r gmat[i,j] = g bmat[i,j] = b rImage = self._arrayToImage(rmat) gImage = self._arrayToImage(gmat) bImage = self._arrayToImage(bmat) super(HSVBitmap,self).__init__(Image.merge('RGB',(rImage,gImage,bImage)))
def _sendchipdata(self, pbStep): if self._chipdataN != None: # approximation coefs = Numeric.zeros((self._chipdataN.shape[0], self.kernelSize+1, self._chipdataN.shape[2]), Numeric.Float) curves = Numeric.zeros(self._chipdataN.shape, Numeric.Float) if self.kernel == 0: appx = chipappx.ApproxOrthPolyBasis(range(self._chipdataN.shape[1]), self.kernelSize+1) self.progressBarAdvance(pbStep) for idx2 in range(self._chipdataN.shape[2]): if self.useSignificance and self.cbUseSignificance.isEnabled(): coefs[:,:,idx2] = appx.getAppxCoef2d_significant(self._chipdataN[:,:,idx2], self.kernelSize+1, self.alphas[self.alpha]) else: coefs[:,:,idx2] = appx.getAppxCoef(self._chipdataN[:,:,idx2]) self.progressBarAdvance(pbStep) curves[:,:,idx2] = appx.getAppxCurve(coefs[:,:,idx2]) self.progressBarAdvance(pbStep) elif self.kernel == 1: appx = chipappx.TrigonomerticBasis(self._chipdataN.shape[1], self.kernelSize+1) self.progressBarAdvance(pbStep) for idx2 in range(self._chipdataN.shape[2]): # 2007-10-11: trigonometric functions do not use getAppxCoef2d_significant #if self.useSignificance and self.cbUseSignificance.isEnabled(): # coefs[:,:,idx2] = appx.getAppxCoef2d_significant(self._chipdataN[:,:,idx2], self.kernelSize+1, self.alphas[self.alpha]) #else: coefs[:,:,idx2] = appx.getAppxCoef(self._chipdataN[:,:,idx2]) self.progressBarAdvance(pbStep) curves[:,:,idx2] = appx.getAppxCurve(coefs[:,:,idx2]) self.progressBarAdvance(pbStep) chipcoefNew = [] # [(dirname0, [etCoef0, etCoef1, ...]), ...] chipcurvesNew = [] # [(dirname0, [etCurves0, etCurves1, ...]), ...] idxTotal = 0 for (dirname, etList) in self._chipdata: etCoefListNew = [] etCurvesListNew = [] for et in etList: # domain with class and metas if et.domain.classVar != None: domainClassMetas = orange.Domain([et.domain.classVar]) else: domainClassMetas = orange.Domain([]) domainClassMetas.addmetas(et.domain.getmetas()) # exampleTable with class and metas etClassMetas = orange.ExampleTable(domainClassMetas, et) # appx. coefficients domainCoef = orange.Domain(map(lambda x: orange.FloatVariable("C%i" % x), range(coefs.shape[1])), None) etCoef = orange.ExampleTable(domainCoef, coefs[:,:,idxTotal].tolist()) etCoefListNew.append(orange.ExampleTable([etCoef, etClassMetas])) etCoefListNew[-1].name = et.name # appx. curve etCurve = orange.ExampleTable(orange.Domain(et.domain.attributes, None), curves[:,:,idxTotal].tolist()) etCurvesListNew.append(orange.ExampleTable([etCurve, etClassMetas])) etCurvesListNew[-1].name = et.name idxTotal += 1 chipcoefNew.append((dirname, etCoefListNew)) chipcurvesNew.append((dirname, etCurvesListNew)) self.send("Approximated Structured Data", chipcurvesNew) self.send("Structured Approximation Coefficients", chipcoefNew) else: self.send("Approximated Structured Data", None) self.send("Structured Approximation Coefficients", None)
def extrude(self): """Virtual Method to do the extrusion along a 3D path with a 2D shape using the gle extrusion. We then get the geometry information using the extrusion method in Feedback mode. This will then be used to build a triangle strip.""" from gle import glec gle.gleSetJoinStyle ( self.normalStyle | self.joinStyle ) glec.gleFeedBack() contpts = Numeric.array(self.shape2D.contpts) contourPoints = contpts[:,:2] contnorm = Numeric.array(self.shape2D.contnorm) contourNormals = contnorm[:,:2] gle.gleExtrusion(contourPoints, contourNormals, self.contourUp, self.trace3D, self.materials[1028].prop[0][:,:3] ) glec.gleTextureMode(0) v,n,s = glec.gleGetTriangleMesh() vinv = Numeric.zeros( v.shape, 'd') vinv[::2] = v[1::2] vinv[1::2] = v[::2] ninv = Numeric.zeros( n.shape, 'd') ninv[::2] = n[1::2] ninv[1::2] = n[::2] return vinv, ninv, s
def sn(signal,noise,stime,npatches): """Compute the optimal S/N for signal, sampled at intervals of stime, and for the total duration represented in the array, against noise represented by the time series noise; npatches overlapping periods are used to estimate the PSD of the noise.""" # compute signal spectrum without windowing or averaging sspec = spect(signal,stime,0) # compute the noise spectrum, using segment averaging nspec = spect(noise,stime,npatches) # interpolate the noise to be defined on the same frequencies # of the signal's spectrum ispec = Numeric.zeros(Numeric.shape(sspec),dtype='d') ispec[:,0] = sspec[:,0] # ispec[:,1] = arrayfns.interp(nspec[:,1],nspec[:,0],ispec[:,0]) ispec[:,1] = linearinterpolate(nspec[:,1],nspec[:,0],ispec[:,0]) # the (S/N)^2 is given by 2T times the integrated ratio # of the spectral densities (the factor of 2 because the spectral # density is one-sided); notice however that the df is 1/T, # so we need only to sum up the array containing the ratio, # and multiply by two sratio = Numeric.zeros(Numeric.shape(sspec)[0],dtype='d') sratio[1:] = sspec[1:,1] / ispec[1:,1] sn2 = 2.0 * sum(sratio[1:]) return math.sqrt(sn2)
def derivatives(self): # make array of numbers depthString = self.getDepthString() self.depth = Numeric.array(depthString, 'c')[2::4].astype(Numeric.Int8) self.dsq = Numeric.reshape(self.depth, (self.w, self.h)) self.fstD = Numeric.zeros((self.w, self.h), Numeric.Int8) self.sndD = Numeric.zeros((self.w, self.h), Numeric.Int8) self.deriv = Numeric.zeros((self.w, self.h), Numeric.Int8) for i in range(1, self.w-1): for j in range(1, self.h-1): a, b = self._derivatives(i,j) self.fstD[i][j] = a self.sndD[i][j] = b self.deriv[i][j] = max(a, b) # self.deriv = Numeric.choose( Numeric.greater(self.fstD,self.sndD), # (self.fstD,self.sndD) ) self.fstDim = Image.fromstring('P', (self.w,self.h), self.fstD.tostring()) self.sndDim = Image.fromstring('P', (self.w,self.h), self.sndD.tostring()) self.derivim = Image.fromstring('P', (self.w,self.h), self.deriv.tostring() )
def read_chk(file): file = open(chkfile,mode='rb') n = array.array('i') n.read(file, 1) naa=n[0] str = array.array('c') str.read(file,naa) seq = str.tostring() out =N.zeros((naa,20), typecode=N.Float64) col =N.zeros((naa), typecode=N.Int) quality = N.zeros((naa), typecode=N.Float64) for i in range(naa): v = array.array('d') v.read(file,20) data=N.array(v, typecode=N.Float64) if sum(data)==0: col[i] = 0 for j in range(20): out[i,j] = qij[aaNum[seq[i]],j] else: col[i] = 1 for j in range(20): out[i,j] = data[mapping[j]] for k in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]: quality[i] = quality[i] - out[i,k]*log(out[i,k]) file.close() return naa, seq, out, col, quality
def test_sequenceRepeats(self): """match2seq sequence repeat test""" seq1 = 'ABCDEFG~~~~~~~~~~~~~~~' seq2 = '~~~~~' mask1, mask2 = compareSequences( seq1, seq2 ) self.assert_( N.all( mask1 == N.zeros( len(seq1 ) )) ) self.assert_( N.all( mask2 == N.zeros( len(seq2 ) )) )
def MaxInnerProd(ser1, ser2, PSD): size = Numeric.shape(ser1)[0] pdlen = size/2 nyquistf = 0.5/15.0 # !!! hardcoded !!!! freqs = Numeric.arange(0,pdlen+1,dtype='d') * (nyquistf / pdlen) if(Numeric.shape(ser2)[0] != size): print "size of time series must be the same" sys.exit(1) if(Numeric.shape(PSD)[0] != pdlen): print "wrong size of psd: ", pdlen, Numeric.shape(PSD) sys.exit(1) fourier1 = FFT.fft(ser1) fourier2 = FFT.fft(ser2) prod1 = Numeric.zeros(pdlen+1, dtype='d') prod2 = Numeric.zeros(pdlen+1, dtype='d') prod1[0] = 0.0 prod1[1:pdlen] = numpy.multiply(fourier1[1:pdlen],numpy.conjugate(fourier2[1:pdlen])) + numpy.multiply(fourier1[-1:pdlen:-1],numpy.conjugate(fourier2[-1:pdlen:-1])) prod1[pdlen] = fourier1[pdlen]*fourier2[pdlen] prod2[0] = 0.0 prod2[1:pdlen] = numpy.multiply(fourier1[1:pdlen],numpy.conjugate(fourier2[1:pdlen]*1.j)) + numpy.multiply((fourier1[-1:pdlen:-1]),numpy.conjugate(fourier2[-1:pdlen:-1]*(-1.j))) prod2[pdlen] = fourier1[pdlen]*fourier2[pdlen] Numeric.divide(prod1[1:], PSD, prod1[1:]) Numeric.divide(prod2[1:], PSD, prod2[1:]) olap0 = 0.0 olappiby2 = 0.0 for i in xrange(pdlen): if (freqs[i] > fLow and freqs[i]<= fHigh): olap0 += prod1[i] olappiby2 += prod2[i] olap0 = 2.0*olap0/float(size) olappiby2 = 2.0*olappiby2/float(size) # olap0 = 2.0*(numpy.sum(prod1[1:]))/float(size) #it must be scaled by dt # olappiby2 = 2.0*(numpy.sum(prod2[1:]))/float(size) #it must be scaled by dt print "angle of maxim. = ", math.atan(olappiby2/olap0) return sqrt(olap0**2 + olappiby2**2)
def getAppxCoef2d_pVals(self, arr2d, maxNumCoef): """Returns[:,j] the probability that coef. j and all subsequent coef. are equal to 0. Reference: Ott, pp.606. Use only the first k appx. coef. with pvals below some alpha. The significance of the coef. estimated by comparing the variance drop of the model2 with the variance of the model1, where: model 1: complete model with maxNumCoef coef. different from 0 model 2: reduced model with coef. in range (0,k) different from 0 null hypothesis (H0): coef. k,k+1,...,maxNumCoef are equal to 0 if H0 rejected (pval below some alpha (e.g. 0.05) -> there exist an important coef. among coef. k,k+1,...,maxNumCoef repeat the test for k=0,1,...maxNumCoef-1 """ assert len(arr2d.shape) == 2, "2d array expected" assert 0 < maxNumCoef <= self.k coefMax = self.getAppxCoef(arr2d, maxNumCoef) curveMax = self.getAppxCurve(coefMax) SSE1 = Numeric.add.reduce((arr2d-curveMax)**2,1) MSE1 = SSE1 / (arr2d.shape[1]-maxNumCoef) #print "SSE1[0], MSE1[0]",SSE1[0], MSE1[0] pvals = Numeric.zeros((arr2d.shape[0], maxNumCoef), Numeric.Float) for k in range(maxNumCoef): # test cofInd: [maxNum-1, maxNum-2, ..., minNum] #print "Keeping %i coeff" % (k) shpk = list(coefMax.shape) shpk[1] -= k coefk = Numeric.concatenate((coefMax[:,:k], Numeric.zeros((shpk), Numeric.Float)),1) curvek = self.getAppxCurve(coefk) SSE2 = Numeric.add.reduce((arr2d-curvek)**2,1) MSdrop =(SSE2-SSE1) / (maxNumCoef-k) F = MSdrop / MSE1 #2007-10-11: F -> F.filled(???) pvals[:,k] = scipy.stats.fprob((maxNumCoef-k), arr2d.shape[1]-maxNumCoef, F.filled(ApproxOrthPolyBasis._F_fillValue)) return pvals
def test_loadDataset(self): the_data = UTisocontour.loadDataset(UTisocontour.CONTOUR_FLOAT, UTisocontour.CONTOUR_REG_3D, 3, 1, ["pot-2eti-glucose-3fields.raw"]); isovar = 0 timestep = 0 isovalue = 0.23 isoc = UTisocontour.getContour3d(the_data, isovar, timestep, isovalue, UTisocontour.NO_COLOR_VARIABLE) print("nvert:", isoc.nvert) print("ntri:", isoc.ntri) #assert isoc.nvert == 12816 assert isoc.nvert == 3204 assert isoc.ntri == 6392 vert = Numeric.zeros((isoc.nvert,3)).astype('f') norm = Numeric.zeros((isoc.nvert,3)).astype('f') col = Numeric.zeros((isoc.nvert)).astype('f') tri = Numeric.zeros((isoc.ntri,3)).astype('i') UTisocontour.getContour3dData(isoc, vert, norm, col, tri, 0) # signature stuff nsig = UTisocontour.getNumberOfSignatures(the_data) sig0 = UTisocontour.getSignatureFunctions(the_data, 0, 0) sig1 = UTisocontour.getSignatureFunctions(the_data, 1, 0) sig2 = UTisocontour.getSignatureFunctions(the_data, 2, 0) print(sig0.name, sig0.nval) print(sig1.name, sig1.nval) print(sig2.name, sig2.nval) print("signatureValues:", UTisocontour.getSignatureValues(the_data, 0, 0, 0.23))
def newMap(width, height): global m, mt m = Numeric.zeros((width, height)) mt = Numeric.zeros((width, height), 'O') (w, h) = m.shape for i in xrange(0, w): for j in xrange(0, h): mt[i,j] = t
def findQuaternionMatrix(collection, point_ref, conf1, conf2 = None, matrix = True ): universe = collection.universe() if conf1.universe != universe: raise ValueError, "conformation is for a different universe" if conf2 is None: conf1, conf2 = conf2, conf1 else: if conf2.universe != universe: raise ValueError, "conformation is for a different universe" ref = conf1 conf = conf2 weights = universe.masses() weights = weights/collection.mass() ref_cms = point_ref.position().array pos = N.zeros((3,), N.Float) pos = point_ref.position(conf).array possq = 0. cross = N.zeros((3, 3), N.Float) for a in collection.atomList(): r = a.position(conf).array - pos r_ref = a.position(ref).array-ref_cms w = weights[a] possq = possq + w*N.add.reduce(r*r) \ + w*N.add.reduce(r_ref*r_ref) cross = cross + w*r[:, N.NewAxis]*r_ref[N.NewAxis, :] k = N.zeros((4, 4), N.Float) k[0, 0] = -cross[0, 0]-cross[1, 1]-cross[2, 2] k[0, 1] = cross[1, 2]-cross[2, 1] k[0, 2] = cross[2, 0]-cross[0, 2] k[0, 3] = cross[0, 1]-cross[1, 0] k[1, 1] = -cross[0, 0]+cross[1, 1]+cross[2, 2] k[1, 2] = -cross[0, 1]-cross[1, 0] k[1, 3] = -cross[0, 2]-cross[2, 0] k[2, 2] = cross[0, 0]-cross[1, 1]+cross[2, 2] k[2, 3] = -cross[1, 2]-cross[2, 1] k[3, 3] = cross[0, 0]+cross[1, 1]-cross[2, 2] for i in range(1, 4): for j in range(i): k[i, j] = k[j, i] k = 2.*k for i in range(4): k[i, i] = k[i, i] + possq - N.add.reduce(pos*pos) import numpy.oldnumeric.linear_algebra as LinearAlgebra e, v = LinearAlgebra.eigenvectors(k) i = N.argmin(e) v = v[i] if v[0] < 0: v = -v if e[i] <= 0.: rms = 0. else: rms = N.sqrt(e[i]) if matrix: emax = N.argmax(e) QuatMatrix = v return Quaternion.Quaternion(QuatMatrix),v, e, e[i],e[emax], rms else: return Quaternion.Quaternion(v), Vector(ref_cms), Vector(pos), rms
def glXQueryExtension( dpy): """ dpy - Display* return - bool, int, int: support, errorBase, eventBase """ errorBase = Numeric.zeros( 1, Numeric.Int32) eventBase = Numeric.zeros( 1, Numeric.Int32) res = _glxlib.glXQueryExtension( dpy, errorBase, eventBase) return res, errorBase[ 0], eventBase[ 0]
def glXQueryVersion( dpy): """ dpy - Display* return - bool, int, int: support, major, minor """ major = Numeric.zeros( 1, Numeric.Int32) minor = Numeric.zeros( 1, Numeric.Int32) res = _glxlib.glXQueryVersion( dpy, major, minor) return res, major[ 0], minor[ 0]
def lowess2(x, y, xest, f=2./3., iter=3): """Returns estimated values of y in data points xest (or None if estimation fails). Lowess smoother: Robust locally weighted regression. The lowess function fits a nonparametric regression curve to a scatterplot. The arrays x and y contain an equal number of elements; each pair (x[i], y[i]) defines a data point in the scatterplot. The function returns the estimated (smooth) values of y. The smoothing span is given by f. A larger value for f will result in a smoother curve. The number of robustifying iterations is given by iter. The function will run faster with a smaller number of iterations.""" x = Numeric.asarray(x, 'd') y = Numeric.asarray(y, 'd') xest = Numeric.asarray(xest, 'd') n = len(x) nest = len(xest) r = min(int(Numeric.ceil(f*n)),n-1) # radius: num. of points to take into LR h = [Numeric.sort(abs(x-x[i]))[r] for i in range(n)] # distance of the r-th point from x[i] w = Numeric.clip(abs(([x]-Numeric.transpose([x]))/h),0.0,1.0) w = 1-w*w*w w = w*w*w hest = [Numeric.sort(abs(x-xest[i]))[r] for i in range(nest)] # r-th min. distance from xest[i] to x west = Numeric.clip(abs(([xest]-Numeric.transpose([x]))/hest),0.0,1.0) # shape: (len(x), len(xest) west = 1-west*west*west west = west*west*west yest = Numeric.zeros(n,'d') yest2 = Numeric.zeros(nest,'d') delta = Numeric.ones(n,'d') try: for iteration in range(iter): # fit xest for i in range(nest): weights = delta * west[:,i] b = Numeric.array([sum(weights*y), sum(weights*y*x)]) A = Numeric.array([[sum(weights), sum(weights*x)], [sum(weights*x), sum(weights*x*x)]]) beta = LinearAlgebra.solve_linear_equations(A,b) yest2[i] = beta[0] + beta[1]*xest[i] # fit x (to calculate residuals and delta) for i in range(n): weights = delta * w[:,i] b = Numeric.array([sum(weights*y), sum(weights*y*x)]) A = Numeric.array([[sum(weights), sum(weights*x)], [sum(weights*x), sum(weights*x*x)]]) beta = LinearAlgebra.solve_linear_equations(A,b) yest[i] = beta[0] + beta[1]*x[i] residuals = y-yest s = MLab.median(abs(residuals)) delta = Numeric.clip(residuals/(6*s),-1,1) delta = 1-delta*delta delta = delta*delta except LinearAlgebra.LinAlgError: print "Warning: NumExtn.lowess2: LinearAlgebra.solve_linear_equations: Singular matrix" yest2 = None return yest2
def _FirstValues(self, data=None, shape=None, datatype=None): if __debug__: if hasattr(DejaVu, 'functionName'): DejaVu.functionName() """Set the initial set of values, always returns a copy""" if data is not None: if len(data)==0: self.ashape = (0,) + self.ashape[1:] return Numeric.zeros( self.ashape, self.type) elif isarray(data): # data is an Numeric array if not datatype: if self.type: datatype = self.type else: raise AttributeError('I Need a datatype') if data.typecode() == self.type: # right type if shape is None: self.ashape = data.shape if data.shape == self.ashape: return Numeric.array(data) else: return Numeric.reshape(data, shape ) else: # bad type data = data.astype(datatype) if shape is None: self.ashape = data.shape # if data.shape == self.ashape: return Numeric.array(data) if data.shape == self.ashape: return data else: return Numeric.reshape(data, shape) else: # data is not an array if datatype and shape: data = Numeric.array( data, self.type) return Numeric.reshape( data, shape ) elif datatype: d=Numeric.array( data, datatype) self.ashape = d.shape return d else: try: d=Numeric.array( data, self.type) except ValueError: raise ValueError('Bad argument') if d.dtype.char in Numeric.typecodes['Integer'] or \ d.dtype.char in Numeric.typecodes['UnsignedInteger']: d=Numeric.array( data, viewerConst.IPRECISION) else: d=Numeric.array( data, viewerConst.FPRECISION) self.ashape = d.shape return d else: # No data if datatype and shape: d = Numeric.zeros( (0,), self.type) d.shape = shape return d else: raise AttributeError('I Need a datatype and a shape')
def __init__(self, points, k, normalization=NORM_NORM_T0_1, force=False): """ calculate k polynomials of degree 0 to k-1 orthogonal on a set of distinct points map points to interval [-1,1] INPUT: points: array of dictinct points where polynomials are orthogonal k: number of polynomials of degree 0 to k-1 force=True creates basis even if orthogonality is not satisfied due to numerical error USES: x: array of points mapped to [-1,1] T_: matrix of values of polynomials calculated at x, shape (k,len(x)) TT_ = T_ * Numeric.transpose(T_) TTinv_ = inverse(TT_) sc_: scaling factors a, b: coefficients for calculating T (2k-4 different from 0, i.e. 6 for k=5) n: number of points = len(points) normalization = {0|1|2} """ self.k = k # number of basis polynomials of order 0 to k-1 self._force = force self.points = Numeric.asarray(points, Numeric.Float) self.pointsMin = min(points) self.pointsMax = max(points) # scaling x to [-1,1] results in smaller a and b, T is not affected; overflow is NOT a problem! self.xMin = -1 self.xMax = 1 self.x = self._map(self.points, self.pointsMin, self.pointsMax, self.xMin, self.xMax) # calculate basis polynomials self.n = len(points) # the number of approximation points t = Numeric.zeros((k,self.n),Numeric.Float) a = Numeric.zeros((k,1),Numeric.Float) b = Numeric.zeros((k,1),Numeric.Float) t[0,:] = Numeric.ones(self.n,Numeric.Float) if k > 1: t[1,:] = self.x - sum(self.x)/self.n for i in range(1,k-1): a[i+1] = Numeric.innerproduct(self.x, t[i,:] * t[i,:]) / Numeric.innerproduct(t[i,:],t[i,:]) b[i] = Numeric.innerproduct(t[i,:], t[i,:]) / Numeric.innerproduct(t[i-1,:],t[i-1,:]) t[i+1,:] = (self.x - a[i+1]) * t[i,:] - b[i] * t[i-1,:] self.a = a self.b = b # prepare for approximation self._T0 = t # orthonormal _TT0 = Numeric.matrixmultiply(self._T0, Numeric.transpose(self._T0)) self.sc1 = Numeric.sqrt(Numeric.reshape(Numeric.diagonal(_TT0),(self.k,1))) # scaling factors = sqrt sum squared self._T0 self._T1 = self._T0 / self.sc1 # orthonormal and T[0] == 1 self.sc2 = Numeric.sqrt(Numeric.reshape(Numeric.diagonal(_TT0),(self.k,1)) / self.n) # scaling factors = sqrt 1/n * sum squared self._T0 self._T2 = self._T0 / self.sc2 # T[:,-1] == 1 self.sc3 = Numeric.take(self._T0, (-1,), 1) # scaling factors = self._T0[:,-1] self._T3 = self._T0 / self.sc3 # set the variables according to the chosen normalization self.setNormalization(normalization)
def ResetTransformation(self, redo=1): if __debug__: if hasattr(DejaVu, 'functionName'): DejaVu.functionName() """Reset the tranformations (Rotation, translation, pivot, scale)""" self.rotation = Numeric.identity(4).astype('f') self.rotation.shape = (16, ) self.translation = Numeric.zeros( (3,), 'f') self.pivot = Numeric.zeros( (3,), 'f') self.scale = Numeric.ones( (3,), 'f') if self.viewer: if self.viewer.currentObject != self.viewer.rootObject \ and redo: self.viewer.deleteOpenglList()
def loadString(mapname, text): compiled = compile(text, mapname, 'exec') localVars = {} eval(compiled, {}, localVars) mapData = localVars if mapData["VERSION"] != 1: raise "Map version %d not supported" % mapData["VERSION"] width = mapData['WIDTH'] height = mapData['HEIGHT'] # tilePropertiesTemplate = {} waterHeight = 0 waterColor = [0.3, 0.3, 0.6] if mapData.has_key('WATER_HEIGHT'): waterHeight = mapData['WATER_HEIGHT'] if mapData.has_key('WATER_COLOR'): waterColor = mapData['WATER_COLOR'] if mapData.has_key('TILE_PROPERTIES'): tags = mapData['TILE_PROPERTIES'] for k in tags.keys(): tags[k]['name'] = k if not tags[k].has_key('waterColor'): tags[k]['waterColor'] = waterColor if not tags[k].has_key('waterHeight'): tags[k]['waterHeight'] = waterHeight else: tags = {} layoutLines = mapData['LAYOUT'].split('\n') layoutLines.pop(0) zdata = Numeric.zeros((width, height)) tileProperties = Numeric.zeros((width, height), Numeric.PyObject) y = 0 for line in layoutLines: if re.match(re.compile(r'^\s*$'), line): continue tiles = re.split(re.compile(r'\s+(?!-?\d+,)(?!-?\d+\])'), line) for x in xrange(0, width): tileData = tiles[x] tileProperties[x,y] = {} m = re.match(re.compile( r'(\d+)(\[(-?\d+), (-?\d+), (-?\d+), (-?\d+)\])?(wh(\d+))?(\w*)'), tileData) zdata[x,y] = int(m.group(1)) tileProperties[x,y]['tag'] = m.group(9) if m.group(2) != None: tileProperties[x,y]['cornerHeights'] = [int(m.group(3)),int(m.group(4)),int(m.group(5)),int(m.group(6))] if m.group(7) != None: tileProperties[x,y]['waterHeight'] = int(m.group(8)) y += 1 m = Map(width, height, zdata, tileProperties, waterHeight, waterColor, tags) m.setLoadString(text) return m
def computeIsocontour(isovalue, data): isoc = isocontour.getContour3d(data, 0, 0, isovalue, isocontour.NO_COLOR_VARIABLE) if isoc.nvert==0 or isoc.ntri==0: return [], [], [] vert = Numeric.zeros((isoc.nvert,3)).astype('f') norm = Numeric.zeros((isoc.nvert,3)).astype('f') col = Numeric.zeros((isoc.nvert)).astype('f') tri = Numeric.zeros((isoc.ntri,3)).astype('i') isocontour.getContour3dData(isoc, vert, norm, col, tri, 0) if len(vert) == 0 or len(tri) == 0: return [], [], [] return vert, tri, norm
def random2DArray( matrix, ranNr=1, mask=None): """ Create randomized 2D array containing ones and zeros. @param matrix: matrix to randomize @type matrix: 2D array @param mask: mask OR None (default: None) @type mask: list(1|0) @param ranNr: number of matricies to add up (default: 1) @type ranNr: integer @return: 2D array or |ranNr| added contact matricies @rtype:2D array @raise MathUtilError: if mask does not fit matrix """ ## get shape of matrix a,b = N.shape( matrix ) ## get array from matrix that is to be randomized if mask is not None: if len(mask) == len( N.ravel(matrix) ): array = N.compress( mask, N.ravel(matrix) ) if len(mask) != len( N.ravel(matrix) ): raise MathUtilError( 'MatUtils.random2DArray - mask of incorrect length' + '\tMatrix length: %i Mask length: %i'\ %(len( N.ravel(matrix) ), len(mask))) if not mask: array = N.ravel(matrix) ## number of ones and length of array nOnes = int( N.sum( array ) ) lenArray = len( array ) ranArray = N.zeros( lenArray ) ## create random array for n in range(ranNr): ranArray += randomMask( nOnes, lenArray ) ## blow up to size of original matix if mask is not None: r = N.zeros(a*b) N.put( r, N.nonzero(mask), ranArray) return N.reshape( r, (a,b) ) if not mask: return N.reshape( ranArray, (a,b) )
def __init__(self, pnts): pnts = numerix.transpose(numerix.asarray(pnts, numerix.Float)) npnts = pnts.shape[1] if npnts < 3: raise NURBSError, 'Point sequence error' cntrl = numerix.zeros((pnts.shape[0], 2 * npnts - 2), numerix.Float) cntrl[:,0] = pnts[:,0] cntrl[:,-1] = pnts[:,-1] cntrl[:,1:-2:2] = pnts[:,1:-1] cntrl[:,2:-1:2] = pnts[:,1:-1] uknots = numerix.zeros(npnts * 2, numerix.Float) uknots[0::2] = numerix.arange(npnts) uknots[1::2] = numerix.arange(npnts) Crv.__init__(self, cntrl, uknots)
def GetMatrix(self, root=None, instance=None, scale=True, transpose=True): if __debug__: if hasattr(DejaVu, 'functionName'): DejaVu.functionName() """Returns the matrix by which this object is transformed scale = False: returns the rotation and translation. no scaling info included Used to save the transformed geom --> coords --> new pdb file instance is a list of integer instance indices for all parents """ if root is None: root = self.viewer.rootObject if instance is None: instance = [0] p = self.parent while p: instance.append(0) p = p.parent GL.glPushMatrix() GL.glLoadIdentity() #print 'GetMatrix', instance self.BuildMat(self, root, scale, instance) #GL.glMultMatrixf(self.instanceMatricesFortran[instanceList[0]]]) m = Numeric.array(GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX)).astype('f') GL.glPopMatrix() if Numeric.alltrue(m==Numeric.zeros(16).astype('f')): # this happens when Pmv has no GUI m = Numeric.identity(4) if transpose: return Numeric.transpose(Numeric.reshape(m, (4,4))) else: return Numeric.reshape(m, (4,4))
def __make_hsv_matrices(self,hsc_matrices,shape,normalize,range_=False): """ Sub-function of plot() that return the h,s,v matrices corresponding to the current matrices in sliced_matrices_dict. The shape of the matrices in the dict is passed, as well as the normalize boolean parameter. The result specified a bitmap in hsv coordinate. Applies normalizing and cropping if required. """ zero=zeros(shape,Float) one=ones(shape,Float) s,h,c = hsc_matrices # Determine appropriate defaults for each matrix if s is None: s=one # Treat as full strength by default if c is None: c=one # Treat as full confidence by default if h is None: # No color, gray-scale plot. h=zero c=zero # If normalizing, offset the matrix so that the minimum # value is 0.0 and then scale to make the maximum 1.0 if normalize!='None': s=self._normalize(s,range_=range_) # CEBALERT: I meant False, right? c=self._normalize(c,range_=False) # This translation from SHC to HSV is valid only for black backgrounds; # it will need to be extended also to support white backgrounds. hue,sat,val=h,c,s return (hue,sat,val)
def __make_rgb_matrices(self, rgb_matrices,shape,normalize,range_=False): """ Sub-function of plot() that return the h,s,v matrices corresponding to the current matrices in sliced_matrices_dict. The shape of the matrices in the dict is passed, as well as the normalize boolean parameter. The result specified a bitmap in hsv coordinate. Applies normalizing and cropping if required. """ zero=zeros(shape,Float) r,g,b = rgb_matrices # Determine appropriate defaults for each matrix if r is None: r=zero if g is None: g=zero if b is None: b=zero # CEBALERT: have I checked this works? if normalize!='None': r = self._normalize(r,range_=range_) g = self._normalize(g,range_=range_) b = self._normalize(b,range_=range_) return (r,g,b)
def _re_bound(self,plot_bounding_box,mat,box,density): # CEBHACKALERT: for Julien... # If plot_bounding_box is that of a Sheet, it will already have been # setup so that the density in the x direction and the density in the # y direction are equal. # If plot_bounding_box comes from elsewhere (i.e. you create it from # arbitrary bounds), it might need to be adjusted to ensure the density # in both directions is the same (see Sheet.__init__()). I don't know where # you want to do that; presumably the code should be common to Sheet and # where it's used in the plotting? # # It's possible we can move some of the functionality # into SheetCoordinateSystem. if plot_bounding_box.containsbb_exclusive(box): ct = SheetCoordinateSystem(plot_bounding_box,density,density) new_mat = zeros(ct.shape,Float) r1,r2,c1,c2 = Slice(box,ct) new_mat[r1:r2,c1:c2] = mat else: scs = SheetCoordinateSystem(box,density,density) s=Slice(plot_bounding_box,scs) s.crop_to_sheet(scs) new_mat = s.submatrix(mat) return new_mat
def __init__(self): self.dataObjectsDict = {} self.Isommet=Numeric.zeros([200], Numeric.Int) # self.VisTable = crtConcentracao.startGui() self.Vispectdic={} self.vinfo={} #self.Elementos=Elementos.Elementos('elementos') self.A1 = None self.B1 = None self.Absi = None self.NoPic = None self.Area = None self.Bgnd = None self.Resol=None self.Id=None self.Fi=None self.Erreur=None self.Lt=None self.sig=None self.ideb=None self.ifin=None self.moyamont = None self.moyaval = None self.Y1 = None self.Y2 = None self.ro=None self.kres=None self.slope=None self.offset=None self.f1zfin=None self.f1zdeb=None self.vy=Numeric.array([],Numeric.Float64)
def __init__(self,**params): """ SLISSOM-specific init, where dynamic threshold stuff gets initialized. """ super(SLISSOM,self).__init__(**params) self.dynamic_threshold = \ Numeric.zeros(self.activity.shape).astype(activity_type) self.spike = Numeric.zeros(self.activity.shape) self.spike_history = Numeric.zeros(self.activity.shape) self.membrane_potential = \ Numeric.zeros(self.activity.shape).astype(activity_type) num_traces = len(self.trace_coords) self.membrane_potential_trace = \ Numeric.zeros((num_traces,self.trace_n)).astype(activity_type)
def InnerProd(ser1, ser2, PSD): size = Numeric.shape(ser1)[0] pdlen = size/2 nyquistf = 0.5/15.0 # !!! hardcoded !!!! freqs = Numeric.arange(0,pdlen+1,dtype='d') * (nyquistf / pdlen) if(Numeric.shape(ser2)[0] != size): print "size of time series must be the same" sys.exit(1) if(Numeric.shape(PSD)[0] != pdlen): print "wrong size of psd: ", pdlen, Numeric.shape(PSD) sys.exit(1) fourier1 = FFT.fft(ser1) fourier2 = FFT.fft(ser2) prod = Numeric.zeros(pdlen+1, dtype='d') prod[0] = 0.0 prod[1:pdlen] = numpy.multiply(fourier1[1:pdlen],numpy.conjugate(fourier2[1:pdlen])) + numpy.multiply(fourier1[-1:pdlen:-1],numpy.conjugate(fourier2[-1:pdlen:-1])) prod[pdlen] = fourier1[pdlen]*fourier2[pdlen] Numeric.divide(prod[1:], PSD, prod[1:]) olap0 = 0.0 for i in xrange(pdlen): if (freqs[i] > fLow and freqs[i]<= fHigh): olap0 += prod[i] olap0 = 2.0*olap0/float(size) # olap0 = 2.0*(numpy.sum(prod[1:]))/float(size) #it must be scaled by dt return olap0
def CalcJacobian(self): """ Use crude numerical differences to approximate Jacobian return inverse """ jacobian = zeros((self.numberActive, self.numberActive), Float) for cont in self.activeControllers: cont.SaveBase() self.errors = self.GetErrors() delta = 0.1 for i in range(self.numberActive): self.flowsheet.InfoMessage('ContDerivCalc', (self.flowsheet.GetPath(), i)) cont = self.activeControllers[i] cont.SetOutput(delta) self.flowsheet.InnerSolve() jacobian[:,i] = (self.GetErrors() - self.errors)/delta cont.SetOutput(0.0) self.flowsheet.InnerSolve() try: self.jacobian = inverse(jacobian) except: raise Error.SimError('CouldNotInvertJacobian', self.flowsheet.GetPath())
def RGBRamp(size=256, upperValue=.6666666666666667): """Generate an RGB color ramp, values range from 0.0 to 1.0""" assert size > 0 hsv = HSVRamp(size, upperValue) rgb = Numeric.zeros( (hsv.shape[0], 3), viewerConst.FPRECISION ) for i in xrange(hsv.shape[0]): rgb[i] = ToRGB(hsv[i]) return rgb
def gluGetTessProperty(tess, property): """ tess - GLUtesselator* property - GLenum return - GLdouble """ data = Numeric.zeros(1, 'd') _glulib.gluGetTessProperty(nurb, property, data) return data[0]
def thumbz_cb(self, events=None): val = self.thumbz.value rot = Numeric.zeros((4, 4), 'f') rot[0][0] = math.cos(val) rot[0][1] = -math.sin(val) rot[1][0] = math.sin(val) rot[1][1] = math.cos(val) rot[2][2] = 1.0 self.updateVector(rot)
def read(self, address, threshold=None): if self.verbose: print "Reading...", s = self.select(address, threshold) counts = Numeric.zeros(self.dataLength) for i in range(len(s)): if s[i]: counts += self.memory[i].counters if self.verbose: print "done!" return [rnd3(x) for x in counts]
def wt2mat(self): n = len(self.neighbors) w = Numeric.zeros((n, n), Numeric.Float) for i in range(n): if self.numneigh[i]: kk = 1.0 / self.numneigh[i] for j in self.neighbors[i]: w[i][j] = kk return w
def gluGetNurbsProperty(nurb, property): """ nurb - GLUnurbs* property - GLenum return - GLfloat """ data = Numeric.zeros(1, 'f') _glulib.gluGetNurbsProperty(nurb, property, data) return data[0]
def getHistogram(self): GL.glHistogram(GL.GL_HISTOGRAM, 256, GL.GL_RGB, GL.GL_FALSE) GL.glEnable(GL.GL_HISTOGRAM) self.redraw() values = Numeric.zeros((256, 3), Numeric.UInt16) #seg faults GL.glGetHistogram(GL.GL_HISTOGRAM, GL.GL_TRUE, GL.GL_RGB, GL.GL_UNSIGNED_SHORT, values) return values
def findNearestAtoms(mol, vertices, **kw): """None <- color(mol,vertices2,**kw) mol: reference molecule vertices: list of lists(coordinates): the first three items in each list must be coordinates x,y,z of a point. atomIndices is the index of the nearest atom to the vertex, such that mol.allAtoms[atomIndices[x]] is the nearest atom to vertices[x] vertexIndices is the list of nearest vertices to an atom, such that vertexIndices[x] = [vertex1,vertex2,...] are the vertices associated with mol.allAtoms[x] """ coords = mol.allAtoms.coords if not hasattr(mol, 'bhtree'): print "Building bhtree for ", mol ids = Numeric.arange(len(coords)).astype('i') bhtree = bhtreelib.TBHTree(coords, ids, 10, 10, 9999.0) mol.bhtree = bhtree vertexIndices = {} atomIndices = {} for x in range(len(coords)): vertexIndices[x + 1] = [] cutoff = 5. for x in range(len(vertices)): xyz = vertices[x] result = Numeric.zeros((len(vertices), )).astype('i') dist = Numeric.zeros((len(vertices), )).astype('f') nb2 = mol.bhtree.ClosePointsDist2(tuple(xyz[:3]), cutoff, result, dist) while nb2 == 0: cutoff = cutoff + 5. nb2 = mol.bhtree.ClosePointsDist2(tuple(xyz[:3]), cutoff, result, dist) result = result[:nb2] dist = dist[:nb2] idx = dist.tolist().index(min(dist)) atnum = result[idx] + 1 atomIndices[x] = atnum vertexIndices[atnum].append(x) return atomIndices, vertexIndices
def readarray(filename): file = open(filename, 'r') lines = [line.split() for line in file.readlines() if line[0] != '#'] file.close() bshape = (len(lines),len(lines[0])) if bshape[1] == 1: buffer = Numeric.zeros(bshape[0],'d') for index in xrange(0,bshape[0]): buffer[index] = float(lines[index][0]) else: buffer = Numeric.zeros(bshape,'d') for index in xrange(0,buffer.shape[0]): buffer[index,:] = map(float,lines[index]) return buffer
def _cylinderTemplate(self): npoly = self.quality * 5 v = Numeric.zeros(((npoly + 1), 2, 3), 'f') n = Numeric.zeros(((npoly + 1), 3), 'f') self.npoly = npoly a = -math.pi # starting angle d = 2 * math.pi / npoly # increment for i in range(npoly + 1): n[i][0] = v[i][0][0] = v[i][1][0] = math.cos(a) n[i][1] = v[i][0][1] = v[i][1][1] = math.sin(a) n[i][2] = v[i][1][2] = 0.0 v[i][0][2] = 1.0 a = a + d return v, n
def __init__(self, radius): """Radius is the the sphere radius (integer). A 3D array of size 2*radius + 1 will contain the discrete sphere """ import numpy.oldnumeric as Numeric size = 2 * radius + 1 self.centerIndex = radius self.grid = Numeric.zeros((size, size, size), Numeric.UnsignedInt8) # put ones in voxels inside or on the sphere self.Sphere(radius)
def vvmult(a, b): """ Compute a vector product for 3D vectors """ import numpy.oldnumeric as Numeric res = Numeric.zeros(3, 'f') res[0] = a[1] * b[2] - a[2] * b[1] res[1] = a[2] * b[0] - a[0] * b[2] res[2] = a[0] * b[1] - a[1] * b[0] return res
def MaxInnerProd(ser1, ser2, PSD): size = Numeric.shape(ser1)[0] pdlen = size / 2 nyquistf = 0.5 / 15.0 # !!! hardcoded !!!! freqs = Numeric.arange(0, pdlen + 1, dtype='d') * (nyquistf / pdlen) if (Numeric.shape(ser2)[0] != size): print "size of time series must be the same" sys.exit(1) if (Numeric.shape(PSD)[0] != pdlen): print "wrong size of psd: ", pdlen, Numeric.shape(PSD) sys.exit(1) fourier1 = FFT.fft(ser1) fourier2 = FFT.fft(ser2) prod1 = Numeric.zeros(pdlen + 1, dtype='d') prod2 = Numeric.zeros(pdlen + 1, dtype='d') prod1[0] = 0.0 prod1[1:pdlen] = numpy.multiply( fourier1[1:pdlen], numpy.conjugate( fourier2[1:pdlen])) + numpy.multiply( fourier1[-1:pdlen:-1], numpy.conjugate(fourier2[-1:pdlen:-1])) prod1[pdlen] = fourier1[pdlen] * fourier2[pdlen] prod2[0] = 0.0 prod2[1:pdlen] = numpy.multiply( fourier1[1:pdlen], numpy.conjugate( fourier2[1:pdlen] * 1.j)) + numpy.multiply( (fourier1[-1:pdlen:-1]), numpy.conjugate(fourier2[-1:pdlen:-1] * (-1.j))) prod2[pdlen] = fourier1[pdlen] * fourier2[pdlen] Numeric.divide(prod1[1:], PSD, prod1[1:]) Numeric.divide(prod2[1:], PSD, prod2[1:]) olap0 = 0.0 olappiby2 = 0.0 for i in xrange(pdlen): if (freqs[i] > fLow and freqs[i] <= fHigh): olap0 += prod1[i] olappiby2 += prod2[i] olap0 = 2.0 * olap0 / float(size) olappiby2 = 2.0 * olappiby2 / float(size) # olap0 = 2.0*(numpy.sum(prod1[1:]))/float(size) #it must be scaled by dt # olappiby2 = 2.0*(numpy.sum(prod2[1:]))/float(size) #it must be scaled by dt print "angle of maxim. = ", math.atan(olappiby2 / olap0) return sqrt(olap0**2 + olappiby2**2)
def _normalize(self, a, range_): """ Normalize an array s to be in the range 0 to 1.0. For an array of identical elements, returns an array of ones if the elements are greater than zero, and zeros if the elements are less than or equal to zero. """ if range_: # i.e. not False, not None (expecting a tuple) range_min = float(range_[0]) range_max = float(range_[1]) if range_min == range_max: if range_min > 0: resu = ones(a.shape) else: resu = zeros(a.shape) else: a_offset = a - range_min resu = a_offset / (range_max - range_min) return resu else: if range_ is None: if not hasattr(self, 'value_range'): self.value_range = (a.min(), a.max()) else: # If normalizing multiple matrices, take the largest values self.value_range = (min(self.value_range[0], a.min()), max(self.value_range[1], a.max())) return None # (indicate that array was not scaled) else: # i.e. range_ is False a_offset = a - a.min() max_a_offset = a_offset.max() if max_a_offset > 0: a = divide(a_offset, float(max_a_offset)) else: if min(a.ravel()) <= 0: a = zeros(a.shape, Float) else: a = ones(a.shape, Float) return a
def _arcTemplate(self, angle): nsegments = self.nsegments assert (nsegments > 1) import numpy.oldnumeric as Numeric, math self.v = Numeric.zeros(((nsegments + 1), 3), 'f') self.n = Numeric.zeros(((nsegments + 1), 3), 'f') self.nsegments = nsegments angRad = angle * pi * 0.00555555555556 a = -pi # starting angle d = angRad / nsegments # increment for i in range(nsegments + 1): self.n[i][0] = self.v[i][0] = cos(a) self.n[i][1] = self.v[i][1] = sin(a) self.n[i][2] = 1.0 self.v[i][2] = 0.0 a = a + d
def rankData(n, inverse=False): """Returns ranks of 1D Numeric array in range 1...shape[0]. """ n = Numeric.asarray(n) assert Numeric.rank(n) == 1 r = Numeric.zeros(n.shape[0], Numeric.Float) Numeric.put(r, Numeric.argsort(n), Numeric.arange(n.shape[0])) if inverse: return -1*r+n.shape[0] else: return r+1
def glAreTexturesResident(textures): """wrapper over _gllib.glAreTexturesResident Return None if all textures are resident, or a Numeric Array. """ ncell = len(textures) residences = Numeric.zeros(ncell, GLboolean) return not(_gllib.glAreTexturesResident( ncell, textures, residences) ) \ and residences or None
def gluProject(obj, model, proj, view): """ obj - seq( 3, GLdouble) model - seq( gl.MODELVIEW_MATRIX, GLfloat) perspective - seq( gl.PROJECTION_MATRIX, GLfloat) view - seq( gl.VIEWPORT, GLfloat) return - Numeric array (shape: (3,), type: GLdouble) """ win = Numeric.zeros(3, GLdouble) gluProjectv(obj, model, proj, view, win[0:1], win[1:2], win[2:3]) return win
def gluUnProject(obj, model, proj, view): """ obj - seq( 3, GLdouble) model - seq( gl.MODELVIEW_MATRIX, GLfloat) perspective - seq( gl.PROJECTION_MATRIX, GLfloat) view - seq( gl.VIEWPORT, GLfloat) return - Numeric.array ( 3, GLdouble) """ win = Numeric.zeros(3, GLdouble) gluUnProjectv(obj, model, proj, view, win) return win[:3]
def getobs(snum,stime,observables,zerotime=0.0,display=0,forcepython=0): if len(Numeric.shape(observables)) == 0: obsobj = checkobs([observables]) if obsobj and (not forcepython): array = Numeric.zeros(snum,dtype='d') if display: lisaswig.fastgetobsc(array,snum,stime,obsobj,zerotime) else: lisaswig.fastgetobs(array,snum,stime,obsobj,zerotime) else: if display: return getobscount(snum,stime,observables,zerotime) else: array = Numeric.zeros(snum,dtype='d') for i in Numeric.arange(0,snum): array[i] = observables(zerotime+i*stime) else: obsobj = checkobs(observables) if obsobj and (not forcepython): obslen = Numeric.shape(observables)[0] array = Numeric.zeros((snum,obslen),dtype='d') if display: lisaswig.fastgetobsc(array,snum,stime,obsobj,zerotime) else: lisaswig.fastgetobs(array,snum,stime,obsobj,zerotime) else: if display: return getobscount(snum,stime,observables,zerotime) else: obslen = Numeric.shape(observables)[0] array = Numeric.zeros((snum,obslen),dtype='d') for i in Numeric.arange(0,snum): for j in xrange(0,obslen): array[i,j] = observables[j](zerotime+i*stime) return array
def _cylinderTemplateDaniel(self, quality=None): """ This template doesn't put the last point over the first point as done in the other template. In addition, it computes and returns face indices. I don't compute normals This template is used by asIndexedyPolygons()""" if quality is None: quality = self.quality * 5 import numpy.oldnumeric as Numeric, math v = Numeric.zeros(((quality), 2, 3), 'f') n = Numeric.zeros(((quality), 3), 'f') f = [] a = -math.pi # starting angle d = 2 * math.pi / quality # increment # compute vertices for i in range(quality): v[i][0][0] = v[i][1][0] = math.cos(a) v[i][0][1] = v[i][1][1] = math.sin(a) v[i][1][2] = 0.0 v[i][0][2] = 1.0 a = a + d lV = len(v) # compute template cylinder faces for i in range(lV - 1): # cylinder body f.append([i, i + 1, lV + i + 1]) f.append([lV + i + 1, lV + i, i]) f.append([lV - 1, 0, lV]) #close last point to first f.append([lV - 1, lV, lV + i + 1]) for i in range(lV - 2): # cylinder bottom cap f.append([0, i + 2, i + 1]) for i in range(lV - 2): # cylinder top cap f.append([lV + i + 1, lV + i + 2, lV]) return v, f
def _NormalizeN(self): eqn = Numeric.zeros((3, ), Numeric.Float) for i in (0, 1, 2): eqn[i] = self.rotation[i] n = Numeric.add.reduce(eqn * eqn) assert n > 0.0 if n > 0.00001: self.n = 1.0 / sqrt(n) self.eqn[:3] = eqn else: self.n = 1.0 self.eqn[:3] = [1.0, 0.0, 0.0]
def patchAround(self, center, nAtoms): """ patchAround( float_center, int_nAtoms ) -> mask for self.model Create single patch of nAtoms atoms that are closest to center. """ dist = self.__distances(center) order = N.argsort(dist) r = N.zeros(len(self.model), 'i') N.put(r, order[:nAtoms], 1) return self.centerPatch(r)
def __init__(self, p00=[-.5, -.5], p01=[.5, -.5], p10=[-.5, .5], p11=[.5, .5]): coefs = numerix.zeros((4, 2, 2), numerix.Float) coefs[3, :, :] = numerix.ones((2, 2), numerix.Float) coefs[0:len(p00), 0, 0] = p00 coefs[0:len(p01), 0, 1] = p01 coefs[0:len(p10), 1, 0] = p10 coefs[0:len(p11), 1, 1] = p11 Srf.__init__(self, coefs, [0., 0., 1., 1.], [0., 0., 1., 1.])
def raggedList2mtrx(raggedList): """convert a bottom triangular ragged list (with optional empty list at the beginning) to a square matrix""" if len(raggedList[0]) == 0: raggedList = raggedList[1:] rlLen = len(raggedList) + 1 m = Numeric.zeros((rlLen, rlLen), Numeric.Float) idx = 0 for lst in raggedList: idx += 1 m[idx, :idx] = Numeric.array(lst, Numeric.Float) m[:idx, idx] = Numeric.array(lst, Numeric.Float) return m
def splag(self, x): n = len(x) if type(x) == list: wx = [0 for i in range(n)] elif type(x) == type(Numeric.array(1)): wx = Numeric.zeros(n, Numeric.Float) for i in range(n): if self.numneigh[i]: for j in self.neighbors[i]: wx[i] += x[j] wx[i] /= self.numneigh[i] return wx
def CreateLinearDistArray(nuVals, bound1, bound2): """Create a Numeric array of values distributed linearly nuVals -- Number of values desired bound1 -- Boundary 1. Can be a numeric array bound2 -- Boundary 2. Can be a numeric array """ if hasattr(bound1, 'shape'): #A bit convoluted but all it does it putting in a list something like this #nuVals =5, shape = (3, 4) -> (5, 3, 4) dim = [nuVals] dim.extend(list(bound1.shape)) vals = zeros(dim, Float) else: vals = zeros(nuVals, Float) delta = (bound2 - bound1) / (nuVals - 1) for i in range(nuVals): vals[i] = delta * i + bound1 return vals
def getAppxCoef(self, arr2d, numCoef=None): """returns approx. coeffients given the number of coefficients different from zero""" assert len(arr2d.shape) == 2 if numCoef == None: numCoef = self.k else: assert 0 <= numCoef <= self.k, "number of coefficients not in range [0," + str( self.k) + "]" coef = self.basis.getApproxCoeff(arr2d) coef[:, numCoef:] = Numeric.zeros( (coef.shape[0], coef.shape[1] - numCoef), Numeric.Float) return coef
def setSignatures(self, signatures): self.signatures = signatures self.sigData = [] # get the values self.maxFun = [] self.minFun = [] for s in self.signatures: x = Numeric.zeros((s.nval, ), 'f') s.getFx(x) self.minix = mini = min(x) if (isinstance(mini, Numeric.ArrayType)) and (mini.shape == ()): mini = mini[0] maxi = max(x) if (isinstance(maxi, Numeric.ArrayType)) and (maxi.shape == ()): maxi = maxi[0] self.rangex = range = maxi - mini if range != 0: x = (((x - mini) / range) * self.widthMinusOne).astype('i') y = Numeric.zeros((s.nval, ), 'f') s.getFy(y) self.sigData.append((x, y)) self.maxFun.append(max(y)) self.minFun.append(min(y)) self.setMin(mini) self.setMax(maxi) # iso value with hightest value in first function if len(self.sigData): ind = list(self.sigData[0][1]).index(max(self.sigData[0][1])) self.setXcursor(ind) else: self.setXcursor(0.0) self.drawSignatures()
def getResult( self, mirror=0 ): """ Get result matrix ordered such as input trajectory. @param mirror: mirror the matrix at diagonal (default: 1) (only for intra-traj) @type mirror: 1|0 @return: array( (n_frames, n_frames), 'f'), matrix of pairwise rms @rtype: array """ if self.verbose: self.log.write('assembling result matrix...') intra_traj = self.traj_2 is None n1 = n2 = len( self.traj_1 ) if self.traj_2 is not None: n2 = len( self.traj_2 ) a = N.zeros( (n1,n2), N.Float32 ) if self.verbose: self.log.write('#') for key, value in self.result.items(): i_start, i_stop = key[0] j_start, j_stop = key[1] window = N.reshape( value, (i_stop-i_start, j_stop-j_start) ) window = window.astype(N.Float32) a[i_start:i_stop, j_start:j_stop] = window if self.verbose: self.log.write('#') if intra_traj: for i in range( N.shape(a)[0] ): for j in range( i, N.shape(a)[1] ): if a[j,i] == 0: a[j,i] = a[i,j] else: a[i,j] = a[j,i] if self.verbose: self.log.write('#') if intra_traj and not mirror: for i in range( N.shape(a)[0] ): for j in range( i, N.shape(a)[1] ): a[j,i] = 0. if self.verbose: self.log.add('done') return a