Пример #1
0
    def degelev(self, utimes, vtimes=None):
        """Degree elevate the surface.
	utimes - degree elevate utimes along u direction.
	vtimes - degree elevate vtimes along v direction."""
        if vtimes:
            if vtimes < 0:
                raise NURBSError, 'Degree must be positive'
            coefs = numerix.resize(
                self.cntrl, (4 * self.cntrl.shape[1], self.cntrl.shape[2]))
            coefs, vknots, nh = bspdegelev(self.degree[1], coefs, self.vknots,
                                           vtimes)
            coefs = coefs[:, :nh + 1]
            self.vknots = vknots[:nh + self.degree[1] + vtimes + 2]
            self.degree[1] += vtimes
            self.cntrl = numerix.resize(
                coefs, (4, self.cntrl.shape[1], coefs.shape[1]))
        if utimes:
            if utimes < 0:
                raise NURBSError, 'Degree must be positive'
            coefs = numerix.transpose(self.cntrl, (0, 2, 1))
            coefs = numerix.resize(
                coefs, (4 * self.cntrl.shape[2], self.cntrl.shape[1]))
            coefs, uknots, nh = bspdegelev(self.degree[0], coefs, self.uknots,
                                           utimes)
            coefs = coefs[:, :nh + 1]
            self.uknots = uknots[:nh + self.degree[0] + utimes + 2]
            self.degree[0] += utimes
            coefs = numerix.resize(coefs,
                                   (4, self.cntrl.shape[2], coefs.shape[1]))
            self.cntrl = numerix.transpose(coefs, (0, 2, 1))
def blurCoordsRadii(coords, radii, blobbyness=-0.1, res=0.5,
                    weights=None, dims=None, padding = 0.0):
    """blur a set of coordinates with radii
"""
    # Setup grid
    resX = resY = resZ = res
    if not dims:
        minb, maxb = blur.getBoundingBox(coords, radii, blobbyness, padding)
        Xdim = int(round( (maxb[0] - minb[0])/resX + 1))
        Ydim = int(round( (maxb[1] - minb[1])/resY + 1))
        Zdim = int(round( (maxb[2] - minb[2])/resZ + 1))
    else:
        Xdim, Ydim, Zdim = dims
    print "Xdim = %d, Ydim =%d, Zdim = %d"%(Xdim, Ydim, Zdim)
    # Generate blur map
    volarr, origin, span = blur.generateBlurmap(
        coords, radii, [Xdim, Ydim, Zdim], blobbyness, weights=weights, padding=padding)
    # Take data from blur map 
    volarr.shape = [Zdim, Ydim, Xdim]
    volarr = Numeric.transpose(volarr).astype('f')
    origin = Numeric.array(origin).astype('f')
    stepsize = Numeric.array(span).astype('f')
    arrayf = Numeric.reshape( Numeric.transpose(volarr),
                              (1, 1)+tuple(volarr.shape) )
    # Return data
    return arrayf, origin, stepsize
Пример #3
0
    def display(self):
	GL.glClearColor( 0.0, 0.0, 0.0, 0.0)
	GL.glClear( GL.GL_COLOR_BUFFER_BIT)
	GL.glColor3f( 1.0,1.0,0.0)
	self.x = self.x + self.move_x
	self.y = self.y + self.move_y
	self.age = self.age + 1
	which = Numeric.greater( self.age, MAX_AGE)
	self.x = Numeric.choose( which, (self.x, RandomArray.random( NUMDOTS)))
	selfy = Numeric.choose( which, (self.y, RandomArray.random( NUMDOTS)))
	self.age = Numeric.choose( which, (self.age, 0))
	self.x = Numeric.choose( Numeric.greater( self.x, 1.0), (self.x, self.x - 1.0)) 
	self.y = Numeric.choose( Numeric.greater( self.y, 1.0), (self.y, self.y - 1.0))
	x2 = RandomArray.random( NUMDOTS2)
	y2 = RandomArray.random( NUMDOTS2)
	v = Numeric.concatenate(
		(Numeric.transpose( Numeric.array( [self.x, self.y])),
		 Numeric.transpose( Numeric.array( [self.x - 0.005, self.y + 0.005])),
		 Numeric.transpose( Numeric.array( [self.x + 0.005, self.y - 0.005])),
		 Numeric.transpose( Numeric.array( [x2, y2]))))
        #from opengltk.util import GLdouble
        #av = bufarray.readArray( v, GLdouble)
	#GL.glVertexPointer( 2, av)
        GL.glVertexPointer( 2, v)
	GL.glEnableClientState( GL.GL_VERTEX_ARRAY)
	#glplus.DrawArrays( GL.POINTS, len( av))
        from opengltk import  glplus
        glplus.DrawArrays( GL.GL_POINTS, len( v))
	#GL.glDisableClientState( GL.VERTEX_ARRAY)
	GL.glFlush()
	GLUT.glutSwapBuffers()
Пример #4
0
 def extractV(self, u):
     "Extract curve in v-direction at parameter u."
     if numerix.any(u < 0.) or numerix.any(u > 1.):
         raise NURBSError, 'Out of parameter range [0,1]'
     if u == 0.:
         cntrl = self.cntrl[:, 0, :]
         knots = self.vknots[:]
     elif u == 1.:
         cntrl = self.cntrl[:, -1, :]
         knots = self.vknots[:]
     else:
         uknots = numerix.repeat(
             numerix.asarray([u], numerix.Float),
             [self.degree[1] * (self.cntrl.shape[2] + 1)])
         coefs = numerix.transpose(self.cntrl, (0, 2, 1))
         coefs = numerix.resize(
             coefs, (4 * self.cntrl.shape[2], self.cntrl.shape[1]))
         coefs, knots = bspkntins(self.degree[0], coefs, self.uknots,
                                  uknots)
         coefs = numerix.resize(coefs,
                                (4, self.cntrl.shape[2], coefs.shape[1]))
         cntrl = numerix.transpose(coefs, (0, 2, 1))
         i = 0
         j = knots[0]
         for k in knots[1:]:
             if k == u:
                 break
             elif k != j:
                 i += 1
                 j = k
     return Crv.Crv(cntrl[:, i, :], self.vknots[:])
Пример #5
0
def blurCoordsRadii(coords,
                    radii,
                    blobbyness=-0.1,
                    res=0.5,
                    weights=None,
                    dims=None,
                    padding=0.0):
    """blur a set of coordinates with radii
"""
    # Setup grid
    resX = resY = resZ = res
    if not dims:
        minb, maxb = blur.getBoundingBox(coords, radii, blobbyness, padding)
        Xdim = int(round((maxb[0] - minb[0]) / resX + 1))
        Ydim = int(round((maxb[1] - minb[1]) / resY + 1))
        Zdim = int(round((maxb[2] - minb[2]) / resZ + 1))
    else:
        Xdim, Ydim, Zdim = dims
    print "Xdim = %d, Ydim =%d, Zdim = %d" % (Xdim, Ydim, Zdim)
    # Generate blur map
    volarr, origin, span = blur.generateBlurmap(coords,
                                                radii, [Xdim, Ydim, Zdim],
                                                blobbyness,
                                                weights=weights,
                                                padding=padding)
    # Take data from blur map
    volarr.shape = [Zdim, Ydim, Xdim]
    volarr = Numeric.transpose(volarr).astype('f')
    origin = Numeric.array(origin).astype('f')
    stepsize = Numeric.array(span).astype('f')
    arrayf = Numeric.reshape(Numeric.transpose(volarr),
                             (1, 1) + tuple(volarr.shape))
    # Return data
    return arrayf, origin, stepsize
Пример #6
0
    def __exposedResidues(self,
                          ASA_values,
                          sidechainCut=0.0,
                          backboneCut=0.0,
                          totalCut=0.0):
        """
        Decide what is a surface exposed residue and what is not.
        sidechainCut, backboneCut, totalCut - float, cutoff value
        for what will be considered as a exposed residue. All
        three values have to pass the test.

        @param ASA_values: array with ASA values for side chains, backbone
                           and total calculated in L{__read_residueASA}.
        @type  ASA_values: array
        @param sidechainCut: cutoff ASA value for considering the side chain
                             to consider thew residue being exposed
                             (default: 0.0) 
        @type  sidechainCut: float
        @param backboneCut: cutoffvalue for back bone ASA
        @type  backboneCut: float 
        @param totalCut: cutoff for total ASA
        @type  totalCut: float   

        @return: residue mask, where 0 = burried
        @rtype: [1|0]
        """
        col_0 = N.greater(N.transpose(ASA_values)[0], totalCut)
        col_1 = N.greater(N.transpose(ASA_values)[1], backboneCut)
        col_2 = N.greater(N.transpose(ASA_values)[2], sidechainCut)

        col_012 = N.concatenate(([col_0], [col_1], [col_2]))

        exposedList = N.greater(N.sum(col_012), 0)

        return exposedList
Пример #7
0
    def FrameTransform(self, camera=None):
        """Build the R an RI, the object's frame transformation and inverse"""

        GL.glPushMatrix()
        self.Si = Numeric.ones((3, ))
        GL.glLoadIdentity()
        m = Numeric.reshape(self.object.rotation, (4, 4))
        upd = Numeric.reshape(Numeric.transpose(m), (16, ))
        GL.glMultMatrixf(self.object.Ri)
        GL.glMultMatrixf(upd)
        GL.glMultMatrixf(self.object.MatrixRotInv)
        self.Si = self.Si * self.object.Si / (self.object.scale *
                                              self.object.MatrixScale)

        self.Ri = Numeric.array(GL.glGetDoublev(
            GL.GL_MODELVIEW_MATRIX)).astype('f')
        GL.glPopMatrix()
        #self.Ri = Numeric.reshape(glCleanRotMat(self.Ri), (4,4) )
        self.Ri = glCleanRotMat(self.Ri)
        self.R = Numeric.reshape(Numeric.transpose(self.Ri),
                                 (16, )).astype('f')
        self.Ri = Numeric.reshape(self.Ri, (16, )).astype('f')

        if self.redirectXform: self.redirectXform.FrameTransform(camera)
        for o in self.copyXform:
            o.FrameTransform(camera)
Пример #8
0
    def __exposedResidues( self, ASA_values, sidechainCut=0.0,
                         backboneCut=0.0, totalCut=0.0  ):
        """
        Decide what is a surface exposed residue and what is not.
        sidechainCut, backboneCut, totalCut - float, cutoff value
        for what will be considered as a exposed residue. All
        three values have to pass the test.

        @param ASA_values: array with ASA values for side chains, backbone
                           and total calculated in L{__read_residueASA}.
        @type  ASA_values: array
        @param sidechainCut: cutoff ASA value for considering the side chain
                             to consider thew residue being exposed
                             (default: 0.0) 
        @type  sidechainCut: float
        @param backboneCut: cutoffvalue for back bone ASA
        @type  backboneCut: float 
        @param totalCut: cutoff for total ASA
        @type  totalCut: float   

        @return: residue mask, where 0 = burried
        @rtype: [1|0]
        """
        col_0 = N.greater( N.transpose(ASA_values)[0], totalCut )
        col_1 = N.greater( N.transpose(ASA_values)[1], backboneCut )
        col_2 = N.greater( N.transpose(ASA_values)[2], sidechainCut )

        col_012 = N.concatenate( ([col_0],[col_1],[col_2]) ) 

        exposedList = N.greater(N.sum(col_012), 0)

        return exposedList
Пример #9
0
 def extractV(self, u):
     "Extract curve in v-direction at parameter u."
     if numerix.any(u < 0.) or numerix.any(u > 1.):
             raise NURBSError, 'Out of parameter range [0,1]'
     if u == 0.:
         cntrl = self.cntrl[:,0,:]
         knots = self.vknots[:]
     elif u == 1.:
         cntrl = self.cntrl[:,-1,:]
         knots = self.vknots[:]
     else:
         uknots = numerix.repeat(numerix.asarray([u], numerix.Float),[self.degree[1]*(self.cntrl.shape[2] + 1)])
         coefs = numerix.transpose(self.cntrl,(0, 2, 1))
         coefs = numerix.resize(coefs,(4*self.cntrl.shape[2], self.cntrl.shape[1]))
         coefs, knots = bspkntins(self.degree[0], coefs, self.uknots, uknots)
         coefs = numerix.resize(coefs, (4, self.cntrl.shape[2], coefs.shape[1]))
         cntrl = numerix.transpose(coefs,(0,2,1))
         i = 0
         j = knots[0]
         for k in knots[1:]:
             if k == u:
                 break
             elif k != j:
                 i += 1
                 j = k
     return Crv.Crv(cntrl[:,i,:], self.vknots[:])
Пример #10
0
    def kntins(self, uknots, vknots=None):
        """Insert new knots into the surface
	uknots - knots to be inserted along u direction
	vknots - knots to be inserted along v direction
	NOTE: No knot multiplicity will be increased beyond the order of the spline"""
        if len(vknots):
            # Force the v knot sequence to be a vector in ascending order
            vknots = numerix.sort(numerix.asarray(vknots, numerix.Float))
            if numerix.any(vknots < 0.) or numerix.any(vknots > 1.):
                raise NURBSError, 'Illegal vknots sequence'
            coefs = numerix.resize(
                self.cntrl, (4 * self.cntrl.shape[1], self.cntrl.shape[2]))
            coefs, self.vknots = bspkntins(self.degree[1], coefs, self.vknots,
                                           vknots)
            self.cntrl = numerix.resize(
                coefs, (4, self.cntrl.shape[1], coefs.shape[1]))
        if len(uknots):
            # Force the u knot sequence to be a vector in ascending order
            uknots = numerix.sort(numerix.asarray(uknots, numerix.Float))
            if numerix.any(uknots < 0.) or numerix.any(uknots > 1.):
                raise NURBSError, 'Illegal uknots sequence'
            coefs = numerix.transpose(self.cntrl, (0, 2, 1))
            coefs = numerix.resize(
                coefs, (4 * self.cntrl.shape[2], self.cntrl.shape[1]))
            coefs, self.uknots = bspkntins(self.degree[0], coefs, self.uknots,
                                           uknots)
            coefs = numerix.resize(coefs,
                                   (4, self.cntrl.shape[2], coefs.shape[1]))
            self.cntrl = numerix.transpose(coefs, (0, 2, 1))
Пример #11
0
def squared_distance_matrix(x, y):

    d1 = N.diagonal(N.dot(x, N.transpose(x)))
    d2 = N.diagonal(N.dot(y, N.transpose(y)))

    a1 = N.add.outer(d1, d2)
    a2 = N.dot(x, N.transpose(y))

    return a1 - 2 * a2
Пример #12
0
def squared_distance_matrix(x, y):

    d1 = N.diagonal(N.dot(x, N.transpose(x)))
    d2 = N.diagonal(N.dot(y, N.transpose(y)))

    a1 = N.add.outer(d1,d2)
    a2 = N.dot(x, N.transpose(y))

    return a1 - 2 * a2
Пример #13
0
    def test_plot(self):
        """gnuplot.plot test"""
        # List of (x, y) pairs
        # plot([(0.,1),(1.,5),(2.,3),(3.,4)])
        # plot( zip( range(10), range(10) ) )

        # Two plots; each given by a 2d array
        import numpy.oldnumeric as N
        x = N.arange(10)
        y1 = x**2
        y2 = (10 - x)**2
        plot(N.transpose(N.array([x, y1])), N.transpose(N.array([x, y2])))
Пример #14
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
Пример #15
0
    def test_plot( self ):
        """gnuplot.plot test"""
        # List of (x, y) pairs
        # plot([(0.,1),(1.,5),(2.,3),(3.,4)])
        # plot( zip( range(10), range(10) ) )

        # Two plots; each given by a 2d array
        import numpy.oldnumeric as N
        x = N.arange(10)
        y1 = x**2
        y2 = (10-x)**2
        plot( N.transpose(N.array([x, y1])), N.transpose(N.array([x, y2])))
Пример #16
0
 def bezier(self, update = None):
     "Decompose surface to bezier patches and return overlaping control points."
     if update or not self._bezier:
         cntrl = numerix.resize(self.cntrl,(4*self.cntrl.shape[1], self.cntrl.shape[2]))
         cntrl = bspbezdecom(self.degree[1], cntrl, self.vknots)
         cntrl = numerix.resize(cntrl, (4, self.cntrl.shape[1], cntrl.shape[1]))
         temp1 = cntrl.shape[1]
         temp2 = cntrl.shape[2]
         cntrl = numerix.transpose(cntrl,(0, 2, 1))
         cntrl = numerix.resize(cntrl,(4*temp2, temp1))
         cntrl = bspbezdecom(self.degree[0], cntrl, self.uknots)
         cntrl = numerix.resize(cntrl, (4, temp2, cntrl.shape[1]))
         self._bezier = numerix.transpose(cntrl,(0, 2, 1))
     return self._bezier
Пример #17
0
    def __pairwiseDistances(self, u, v):
        """
        pairwise distance between 2 3-D numpy arrays of atom coordinates.

        @param u: coordinates
        @type  u: array
        @param v: coordinates
        @type  v: array
        
        @return: Numpy array len(u) x len(v)
        @rtype:array
        
        @author: Wolfgang Rieping.
        """
        ## check input
        if not type( u ) == arraytype or\
           not type( v ) == arraytype:
            raise ComplexError('unsupported argument type ' + \
                               str( type(u) ) + ' or ' + str( type(v) ) )

        diag1= N.diagonal(N.dot(u,N.transpose(u)))
        diag2= N.diagonal(N.dot(v,N.transpose(v)))
        dist= -N.dot(v,N.transpose(u))-N.transpose(N.dot(u,N.transpose(v)))
        dist= N.transpose(N.asarray(map(lambda column,a:column+a, \
                                   N.transpose(dist), diag1)))

        return N.transpose(N.sqrt(N.asarray(
            map(lambda row,a: row+a, dist, diag2))))
Пример #18
0
 def _getBasisCoef(self, x, T):
     """returns coefficients of basis polynomials given T, i.e. their values at x: (poly0, xi)
     where polynomials in rows, coefficients [a0,a1,...ak] where k=len(x)-1
     similar goes for T
     """
     numPoints = T.shape[1]  # number of points that polynomials are calculated == len(x)
     assert len(x) == numPoints, "len(x)=" + str(x) + ", T.shape[1]=" + str(numPoints) + " do not match"
     numLinSys = T.shape[0]  # number of polynomials
     lin_sys_b = Numeric.transpose(T)
     lin_sys_a = Numeric.ones((numPoints, numPoints), Numeric.Float)
     lin_sys_a[:,1] = x
     for idx in range(2,numPoints):
         lin_sys_a[:,idx] = lin_sys_a[:,idx-1] * x
     return Numeric.transpose(LinearAlgebra.solve_linear_equations(lin_sys_a, lin_sys_b))
Пример #19
0
 def bezier(self, update = None):
     "Decompose surface to bezier patches and return overlaping control points."
     if update or not self._bezier:
         cntrl = numerix.resize(self.cntrl,(4*self.cntrl.shape[1], self.cntrl.shape[2]))
         cntrl = bspbezdecom(self.degree[1], cntrl, self.vknots)
         cntrl = numerix.resize(cntrl, (4, self.cntrl.shape[1], cntrl.shape[1]))
         temp1 = cntrl.shape[1]
         temp2 = cntrl.shape[2]
         cntrl = numerix.transpose(cntrl,(0, 2, 1))
         cntrl = numerix.resize(cntrl,(4*temp2, temp1))
         cntrl = bspbezdecom(self.degree[0], cntrl, self.uknots)
         cntrl = numerix.resize(cntrl, (4, temp2, cntrl.shape[1]))
         self._bezier = numerix.transpose(cntrl,(0, 2, 1))
     return self._bezier
Пример #20
0
def pca(data):

    transposed = 0

    if shape(data)[0] < shape(data)[1]:
        transposed = 1
        data = transpose(data)
        
    cov = dot(transpose(data), data)

    ## eigenvectors are row vectors
    val, vec = eigenvectors(cov)

    try:
        val = val.real
    except:
        pass

    try:
        vec = vec.real
    except:
        pass

    order = argsort(val)

    val = Numeric.take(val, order)
    vec = Numeric.take(vec, order)

    pc = Numeric.dot(data, transpose(vec))

    if transposed:
        pc = Numeric.transpose(pc)
    
    return val, vec, pc
Пример #21
0
def histogram(data, nbins, range = None):
    """
    Comes from Konrad Hinsen: Scientific Python
    """
    
    data = Numeric.array(data, Numeric.Float)
    
    if range is None:
        min = Numeric.minimum.reduce(data)
        max = Numeric.maximum.reduce(data)
    else:
        min, max = range
        data = Numeric.repeat(data,
                  Numeric.logical_and(Numeric.less_equal(data, max),
                          Numeric.greater_equal(data,
                                    min)))
    # end if
    bin_width = (max-min)/nbins
    
    data = Numeric.floor((data - min)/bin_width).astype(Numeric.Int)
    histo = Numeric.add.reduce(Numeric.equal(
    Numeric.arange(nbins)[:,Numeric.NewAxis], data), -1)
    histo[-1] = histo[-1] + Numeric.add.reduce(Numeric.equal(nbins, data))
    bins = min + bin_width*(Numeric.arange(nbins)+0.5)
    return Numeric.transpose(Numeric.array([bins, histo]))
Пример #22
0
def inverse4X4(matrix):
    """ returns the inverse of the given 4x4 transformation matrix
t_1: the negetive of Translation vector
r_1: the inverse of rotation matrix

inversed transformation is
1) t_1 applied first
2) then r_1 is applied

to validate the result, N.dot(matrix, mat_inverse)==N.identity(4,'f')
"""
    # check the shape
    if matrix.shape !=(4,4) and matrix.shape !=(16,) :
        raise ValueError("Argument must Numeric array of shape (4,4) or (16,)")
        return None
    if matrix.shape ==(16,):            
        matrix=N.array(matrix,'f')
        matrix=N.reshape(matrix,(4,4))  # force the matrix to be (4,4)
    t_1=N.identity(4,'f')
    t_1[:2,3]= - matrix[:2, 3]
    r_1=N.identity(4,'f')
    r_1[:3,:3] = N.transpose(matrix[:3,:3])
    mat_inverse=N.dot(r_1, t_1)
    #asert N.dot(matrix, mat_inverse) is N.identity(4,'f')
    return mat_inverse
Пример #23
0
def pca(data):

    transposed = 0

    if shape(data)[0] < shape(data)[1]:
        transposed = 1
        data = transpose(data)

    cov = dot(transpose(data), data)

    ## eigenvectors are row vectors
    val, vec = eigenvectors(cov)

    try:
        val = val.real
    except:
        pass

    try:
        vec = vec.real
    except:
        pass

    order = argsort(val)

    val = Numeric.take(val, order)
    vec = Numeric.take(vec, order)

    pc = Numeric.dot(data, transpose(vec))

    if transposed:
        pc = Numeric.transpose(pc)

    return val, vec, pc
Пример #24
0
    def rotate(self, rot, coords):
        """Apply rotation to the coordinates. Rotation can be a 3x3 matrix or
        3 Euler angles"""

        if isinstance(rot[0], types.FloatType):
            rot = EulerAnglesToMat(rot)
        return Numeric.dot(coords, Numeric.transpose(rot)) 
Пример #25
0
 def trim(self):
     """get rid of any universal gaps in the alignment.
     """
     #make sure we have an alignment
     if len(self)==0:
         return
     #make sure we have an up-to-date matrix
     if not hasattr(self,'matrix'):
         self.makeMatrix()
     nsequences,nresidues = Numeric.shape(self.matrix)
     if (nsequences != len(self.sequences) or
         nresidues != len(self)):
         self.makeMatrix()
     transpose = Numeric.transpose(self.matrix)
     gaplist = []
     #any row with sum=0 in the transpose corresponds to a column in the alignment
     #which is all gaps. So add the positions of these columns to the gaplist
     for x in range(len(transpose)):
         line = transpose[x]
         if Numeric.sum(line)==0:
             gaplist.append(x)
     #now can simply pop the unwanted gaps out of each sequence.
     gaplist.reverse()            
     for sequence in self:
         for gap in gaplist:
             junk=sequence.sequence.pop(gap)
             junk=sequence.gappednumbers.pop(gap)
Пример #26
0
    def takeMembers(self, mIndices):
        """
        Take all frames belonging to the members in mIndices::
          takeMembers( mIndices ) -> EnsembleTraj with frames of given members
        
        @param mIndices: list of member indices
        @type  mIndices: [int] OR array('i')
        
        @return: EnsembleTraj with specified members
        @rtype: EnsembleTraj
        
        @todo: return self.__class__ instead of EnsembleTraj
        """
        try:
            ## assumes that each member traj has same number of frames
            fi = N.array([self.memberIndices(i) for i in mIndices])
            fi = N.ravel(N.transpose(fi))

            n_members = len(mIndices)

            ## has wrong n_members and member order
            t = self.takeFrames(fi)

            result = EnsembleTraj(n_members=n_members)

            result.__dict__.update(t.__dict__)
            result.n_members = n_members
            result.resetFrameNames()

            return result

        except TypeError:
            raise EnsembleTrajError, 'takeMembers TypeError '+\
                  str(mIndices)+\
                  "\nlenFrames: %i; n_members: %i" %(len(self), self.n_members)
Пример #27
0
def histogram(data, nbins, range=None):
    """
    Create a histogram.
    Comes from Konrad Hinsen: Scientific Python

    @param data: data list or array
    @type  data: [any]
    @param nbins: number of bins
    @type  nbins: int
    @param range: data range to create histogram from (min val, max val)
    @type  range: (float, float) OR None

    @return: array (2 x len(data) ) with start of bin and witdh of bin. 
    @rtype: array
    """
    data = Numeric.array(data, Numeric.Float)
    if range is None:
        min = Numeric.minimum.reduce(data)
        max = Numeric.maximum.reduce(data)
    else:
        min, max = range
        data = Numeric.repeat(
            data,
            Numeric.logical_and(Numeric.less_equal(data, max),
                                Numeric.greater_equal(data, min)))
    bin_width = (max - min) / nbins
    data = Numeric.floor((data - min) / bin_width).astype(Numeric.Int)
    histo = Numeric.add.reduce(
        Numeric.equal(Numeric.arange(nbins)[:, Numeric.NewAxis], data), -1)
    histo[-1] = histo[-1] + Numeric.add.reduce(Numeric.equal(nbins, data))
    bins = min + bin_width * (Numeric.arange(nbins) + 0.5)
    return Numeric.transpose(Numeric.array([bins, histo]))
Пример #28
0
def findTransformation(x, y):
    """
    Match two arrays by rotation and translation. Returns the
    rotation matrix and the translation vector.

    @param x: first set of coordinates
    @type  x: array('f')
    @param y: second set of coordinates
    @type  y: array('f')

    @return: rotation matrix (3x3) and translation vector (1x3)
    @rtype:  array, array
    """
    ## center configurations
    x_av = N.average(x)
    y_av = N.average(y)

    x = x - x_av
    y = y - y_av

    ## svd of correlation matrix
    v, l, u = svd(N.dot(N.transpose(x), y))

    ## build rotation matrix and translation vector
    r = N.dot(v, u)

    t = x_av - N.dot(r, y_av)

    return r, t
Пример #29
0
 def grayRamp(self):
     self.byte_map = Numeric.transpose(
         Numeric.array([range(256),
                        range(256),
                        range(256),
                        range(256)])).astype(Numeric.UnsignedInt8)
     self.volume.uploadColorMap(self.byte_map)
Пример #30
0
def loessMA(m, windowSize, axis=0, approxMasked=True, verbose=False, callback=None):
    """Returns a new array with values at the given axis smoothed by loess;
    if approxMasked==True: the masked values are approximated by loess;
    assumes equidistant spacing of points on the given axis.
    """
    assert 0 < windowSize <= m.shape[axis]+0.1, "0 < windowSize[%s] <= 1 OR windowSize in range(1.1,m.shape[axis]+1) expected, got %f" % ("%", windowSize)
    m = MA.asarray(m)
    if m.dtype.char <> Numeric.Float:
        m = m.astype(Numeric.Float)
    shp_other = list(m.shape)
    shp_other.pop(axis)
    # get a transposed and reshaped mask and data from m; if m.mask() == None, construct a new array of zeros
    mask = Numeric.reshape(Numeric.transpose(MA.getmaskarray(m), [axis] + range(0,axis) + range(axis+1,len(m.shape))), (m.shape[axis], Numeric.multiply.reduce(shp_other)))
    data = MA.reshape(MA.transpose(m, [axis] + range(0,axis) + range(axis+1,len(m.shape))), (m.shape[axis], Numeric.multiply.reduce(shp_other)))
    maskInv = -1*(mask-1)
    xall = Numeric.arange(data.shape[0])
    xallList = xall.tolist()
    for ii in Numeric.compress(Numeric.add.reduce(maskInv,0) > 1, range(data.shape[1])):    # run loess if the profile contains more than 2 values
        try:
            data[:,ii] = MA.array(statc.loess(zip(MA.compress(maskInv[:,ii], xall).tolist(), MA.compress(maskInv[:,ii], data[:,ii]).tolist()), xallList, windowSize))[:,1]
        except:
            if verbose:
                print "Warning: loessMA: could not loess axis %i index %i" % (axis, ii)
        if callback:
            callback()
    if not approxMasked:
        data = MA.array(data, mask=mask)
    return MA.transpose(MA.reshape(data, [m.shape[axis]] + shp_other), [axis] + range(0,axis) + range(axis+1,len(m.shape)))
Пример #31
0
    def contactResDistribution( self, cm=None ):
        """
        Count occurrence of residues in protein-protein interface.
        
        @param cm: pre-calculated contact matrix (default: None)
        @type  cm: matrix
        
        @return: dict {'A':3, 'C':1, .. } (20 standard amino acids)
        @rtype: dict
        """
        if cm == None:
            cm = self.resContacts()

        ## get mask for residues involved in contacts
        maskLig = N.sum( cm )
        maskRec = N.sum( N.transpose( cm ))

        ## get sequence of contact residues only
        seqLig = N.compress( maskLig, self.lig().sequence() )
        seqRec = N.compress( maskRec, self.rec().sequence() )
        seq    = ''.join( seqLig ) + ''.join(seqRec) ## convert back to string

        ## count occurrence of letters
        result = {}
        for aa in molUtils.allAA():
            result[aa] = seq.count( aa )

        return result
Пример #32
0
    def takeMembers( self, mIndices ):
        """
        Take all frames belonging to the members in mIndices::
          takeMembers( mIndices ) -> EnsembleTraj with frames of given members
        
        @param mIndices: list of member indices
        @type  mIndices: [int] OR array('i')
        
        @return: EnsembleTraj with specified members
        @rtype: EnsembleTraj
        
        @todo: return self.__class__ instead of EnsembleTraj
        """
        try:
            ## assumes that each member traj has same number of frames
            fi = N.array( [ self.memberIndices( i ) for i in mIndices ] )
            fi = N.ravel( N.transpose( fi ) )

            n_members = len( mIndices )

            ## has wrong n_members and member order
            t = self.takeFrames( fi )

            result = EnsembleTraj( n_members=n_members )

            result.__dict__.update( t.__dict__ )
            result.n_members = n_members
            result.resetFrameNames()

            return result

        except TypeError:
            raise EnsembleTrajError, 'takeMembers TypeError '+\
                  str(mIndices)+\
                  "\nlenFrames: %i; n_members: %i" %(len(self), self.n_members)
Пример #33
0
    def buildTexture(self):
        """Build a 2D Texture object and compute texture coordinates for
self.array, using self.colormap to colorize the texture.
"""
        width, height = self.array.shape
        # find smallest power of 2 larger than shape
        dim1=dim2=1
        while dim1<width: dim1 = dim1<<1
        while dim2<height: dim2 = dim2<<1

        # compute texture indices
        r1=float(width)/float(dim1)
        r2=float(height)/float(dim2)
        textCoords = ((0,0), (r1,0), (r1, r2), (0, r2))

        # build texture object for DejaVu
        sl = Numeric.array(Numeric.transpose(self.array))

        # use this line when new color map will be used
        colors = self.colormap.Map(sl.ravel())

        colors.shape = (height, width, -1)
        colors = colors*255
        colors = colors.astype('B')

        tex2DimageArr = Numeric.zeros((dim2,dim1,colors.shape[2]), 'B')
        tex2DimageArr[:height,:width] = colors

        tex = Texture()
        tex.Set(enable=1, image=tex2DimageArr, auto=0)
        tex.width = dim1
        tex.height = dim2

        return tex, textCoords
Пример #34
0
def histogram(data, nbins, range = None):
    """
    Create a histogram.
    Comes from Konrad Hinsen: Scientific Python

    @param data: data list or array
    @type  data: [any]
    @param nbins: number of bins
    @type  nbins: int
    @param range: data range to create histogram from (min val, max val)
    @type  range: (float, float) OR None

    @return: array (2 x len(data) ) with start of bin and witdh of bin. 
    @rtype: array
    """
    data = Numeric.array(data, Numeric.Float)
    if range is None:
        min = Numeric.minimum.reduce(data)
        max = Numeric.maximum.reduce(data)
    else:
        min, max = range
        data = Numeric.repeat(data,
                              Numeric.logical_and(Numeric.less_equal(data, max),
                                                  Numeric.greater_equal(data, min)))
    bin_width = (max-min)/nbins
    data = Numeric.floor((data - min)/bin_width).astype(Numeric.Int)
    histo = Numeric.add.reduce(Numeric.equal(
        Numeric.arange(nbins)[:,Numeric.NewAxis], data), -1)
    histo[-1] = histo[-1] + Numeric.add.reduce(Numeric.equal(nbins, data))
    bins = min + bin_width*(Numeric.arange(nbins)+0.5)
    return Numeric.transpose(Numeric.array([bins, histo]))
Пример #35
0
def view(*args, **kwargs):
    import NumTut
    import graphics
    from numpy.oldnumeric import transpose

    rgb = apply(Graphics.get_image_display_data, args, kwargs)
    NumTut.view(transpose(rgb, (1, 0, 2)))
Пример #36
0
def histogram(data, nbins, range=None):
    """
    Comes from Konrad Hinsen: Scientific Python
    """

    data = Numeric.array(data, Numeric.Float)

    if range is None:
        min = Numeric.minimum.reduce(data)
        max = Numeric.maximum.reduce(data)
    else:
        min, max = range
        data = Numeric.repeat(
            data,
            Numeric.logical_and(Numeric.less_equal(data, max),
                                Numeric.greater_equal(data, min)))
    # end if
    bin_width = (max - min) / nbins

    data = Numeric.floor((data - min) / bin_width).astype(Numeric.Int)
    histo = Numeric.add.reduce(
        Numeric.equal(Numeric.arange(nbins)[:, Numeric.NewAxis], data), -1)
    histo[-1] = histo[-1] + Numeric.add.reduce(Numeric.equal(nbins, data))
    bins = min + bin_width * (Numeric.arange(nbins) + 0.5)
    return Numeric.transpose(Numeric.array([bins, histo]))
Пример #37
0
def findTransformation(x, y):
    """
    Match two arrays by rotation and translation. Returns the
    rotation matrix and the translation vector.

    @param x: first set of coordinates
    @type  x: array('f')
    @param y: second set of coordinates
    @type  y: array('f')

    @return: rotation matrix (3x3) and translation vector (1x3)
    @rtype:  array, array
    """
    ## center configurations
    x_av = N.average(x)
    y_av = N.average(y)

    x = x - x_av
    y = y - y_av


    ## svd of correlation matrix
    v, l, u = svd(N.dot(N.transpose(x), y))

    ## build rotation matrix and translation vector
    r = N.dot(v, u)

    t = x_av - N.dot(r, y_av)

    return r, t
Пример #38
0
 def vunrot(self, v):
     # for use with row vectors
     # [bruce comment 050518: the above old comment by Josh seems to contradict
     #  the comment about 'matrix' in __getattr__ (also old and by Josh)
     #  that it's the transpose of the normal form so it can be used for row vectors.
     #  See the other comment for more info.]
     return Numeric.matrixmultiply(v, Numeric.transpose(self.matrix))
Пример #39
0
    def __findTransformation(self, x, y):
        """
        Match two arrays by rotation and translation. Returns the
        rotation matrix and the translation vector.
        Back transformation:
        for atom i new coordinates will be::
            y_new[i] = N.dot(r, y[i]) + t
            
        for all atoms in one step::
            y_new = N.dot(y, N.transpose(r)) + t

        @param x: coordinates
        @type  x: array
        @param y: coordinates
        @type  y: array

        @return: rotation matrix, translation vector
        @rtype: array, array      
        
        @author: Michael Habeck
        """
        from numpy.oldnumeric.linear_algebra import singular_value_decomposition as svd

        ## center configurations
        x_av = N.sum(x) / len(x)
        y_av = N.sum(y) / len(y)
        x = x - x_av
        y = y - y_av
        ## svd of correlation matrix
        v, l, u = svd(N.dot(N.transpose(x), y))
        ## build rotation matrix and translation vector
        r = N.dot(v, u)
        t = x_av - N.dot(r, y_av)

        return r, t
Пример #40
0
def mad(m,axis=0):
    """Returns Median Absolute Deviation of the given array along the given axis.
    """
    m = Numeric.asarray(m)
    mx = Numeric.asarray(median(m,axis),Numeric.Float)
    xt = Numeric.transpose(m, [axis]+range(axis)+range(axis+1,Numeric.rank(m))) # do not use swapaxes: (0,1,2) -swap-> (2,1,0); (0,1,2) -transpose-> (2,0,1)
    return MLab.median(Numeric.absolute(xt-mx))
Пример #41
0
    def prepareBillboardAndNormalForAllTextLines(self):
        if self.billboard:
            m = self.GetMatrix()
            m = Numeric.reshape(m, (16, ))
            rot = glCleanRotMat(m)  #much faster than self.Decompose4x4(m)

            if self.includeCameraRotationInBillboard:
                # this permit billboarding even if the camera is not in the Z axis
                lCameraTransformation = self.viewer.currentCamera.GetMatrix()
                lCameraTransformation = Numeric.reshape(
                    lCameraTransformation, (16, ))
                lCameraRotation = glCleanRotMat(
                    lCameraTransformation
                )  #much faster than self.Decompose4x4(m)
                lCameraRotation = Numeric.transpose(lCameraRotation)
                rot = Numeric.dot(lCameraRotation, rot)

            rot = Numeric.reshape(rot, (16, ))
            self.billboardRotation = rot.astype('f')
        else:
            c = self.vertexSet.vertices.array
            n = self.vertexSet.normals.array
            lenn = len(n)
            if lenn > 0 and lenn != len(c):
                lMat = rotax.rotVectToVect(n[0], (0, 0, 1))
                self.orientation = [
                    lMat[0][0], lMat[0][1], lMat[0][2], lMat[0][3], lMat[1][0],
                    lMat[1][1], lMat[1][2], lMat[1][3], lMat[2][0], lMat[2][1],
                    lMat[2][2], lMat[2][3], lMat[3][0], lMat[3][1], lMat[3][2],
                    lMat[3][3]
                ]
Пример #42
0
def inverse4X4(matrix):
    """ returns the inverse of the given 4x4 transformation matrix
t_1: the negetive of Translation vector
r_1: the inverse of rotation matrix

inversed transformation is
1) t_1 applied first
2) then r_1 is applied

to validate the result, N.dot(matrix, mat_inverse)==N.identity(4,'f')
"""
    # check the shape
    if matrix.shape != (4, 4) and matrix.shape != (16, ):
        raise ValueError("Argument must Numeric array of shape (4,4) or (16,)")
        return None
    if matrix.shape == (16, ):
        matrix = N.array(matrix, 'f')
        matrix = N.reshape(matrix, (4, 4))  # force the matrix to be (4,4)
    t_1 = N.identity(4, 'f')
    t_1[:2, 3] = -matrix[:2, 3]
    r_1 = N.identity(4, 'f')
    r_1[:3, :3] = N.transpose(matrix[:3, :3])
    mat_inverse = N.dot(r_1, t_1)
    #asert N.dot(matrix, mat_inverse) is N.identity(4,'f')
    return mat_inverse
Пример #43
0
    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))
Пример #44
0
    def setMatrixComponents(self, rot=None, trans=None, scale=None,
                            redo=1):
        if __debug__:
         if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
        """Define MatrixRot, MatrixTransl, MatrixScale and MatrixRotInv
from a rotation, translation and scale.
rot should be a 4x4 matrix defining a 3D 3x3 rotation 
trans should be a 3D translation vector
scale should be 3-vector of positive number larger than 0.0
"""
        self._modified = True
        if rot is not None:
            assert rot.shape==(4,4)
            self.MatrixRot = rot.ravel()
            RotInv = Numeric.transpose(rot)
            self.MatrixRotInv = Numeric.reshape(RotInv, (16,))

        if trans is not None:
            assert len(trans)==3
            self.MatrixTransl = trans

        if scale is not None:
            assert len(scale)==3 and scale[0]>0. and scale[1]>0. and scale[2]>0.
            self.MatrixScale = scale

        if redo:
            self.RedoDisplayList()
            self.viewer.Redraw()
Пример #45
0
 def mul(self, coords, mat):
     shape = coords.shape
     assert shape[-1]==3
     #coords = Numeric.reshape(coords, (-1, shape[-1]))
     one = Numeric.ones((shape[0],1),'f')
     c = Numeric.concatenate((coords, one),1)
     coords = Numeric.array(Numeric.reshape(coords, shape))
     return Numeric.array(Numeric.dot(c, Numeric.transpose(mat))[:,:3])
Пример #46
0
    def dot(self, other):
        "Returns the contraction with |other|."
	if isTensor(other):
	    a = self.array
	    b =  Numeric.transpose(other.array, range(1, other.rank)+[0])
	    return Tensor(Numeric.innerproduct(a, b), 1)
	else:
	    return Tensor(self.array*other, 1)
Пример #47
0
def getCTCSS(tone, sampleRate=44100, peak=0.9):
    if tone in CTCSSTones:
        tone = CTCSSTones[tone]
    length = sampleRate / float(tone)
    omega = Numeric.pi * 2 / length
    xvalues = Numeric.arange(int(length)) * omega
    oneCycle =  ((peak * 32767) * Numeric.sin(xvalues)).astype(Numeric.Int16)
    return Numeric.transpose(Numeric.array((oneCycle,oneCycle)))
Пример #48
0
    def matrix_is_symplectic(self, m, tolerance=1.0e-12):
        """

        Confirm that a given matrix $M$ is symplectic to within
        numerical tolerance.

        This is done by taking the 4 submatrices:

         1. $A = M[0::2, 0::2]$, i.e., configuration coordinates only,

         2. $B = M[0::2, 1::2]$, i.e., configuration rows, momenta cols,

         3. $C = M[1::2, 0::2]$, i.e., momenta rows, configuration cols,

         4. $D = M[1::2, 1::2]$, i.e., momenta only,

        and verifying the following symplectic identities:-
        
         1. $MJM^{T} = J$, the $2n\\times 2n$ sympletic matrix,
        
         2. $AD^{T}-BC^{T} = I$, the $n\\times n$ identity,
            
         3. $AB^{T}-BA^{T} = Z$, the $n\\times n$ zero,
            
         4. $CD^{T}-DC^{T} = Z$.

        Finally, we confirm that $\\det{M} = 1$.

        """
        det = determinant(m)
        j = self.skew_symmetric_matrix()
        approx_j = matrixmultiply(m, matrixmultiply(j, transpose(m)))
        a = m[0::2, 0::2] #even, even
        b = m[0::2, 1::2] #even, odd
        c = m[1::2, 0::2] #odd, even
        d = m[1::2, 1::2] #odd, odd
        i = self.identity_matrix(self.dof())
        approx_i = matrixmultiply(a, transpose(d)) - matrixmultiply(b, transpose(c))
        approx_z0 = matrixmultiply(a, transpose(b)) - matrixmultiply(b, transpose(a))
        approx_z1 = matrixmultiply(c, transpose(d)) - matrixmultiply(d, transpose(c))
        norm = self.matrix_norm
        logger.info('Matrix from diagonal to equilibrium coordinates:')
        logger.info('[output supressed]') #logger.info(m)
        logger.info('error in determinant:            %s', abs(det-1.0))
        logger.info('error in symplectic identity #1: %s', norm(approx_j - j))
        logger.info('error in symplectic identity #2: %s', norm(approx_i - i))
        logger.info('error in symplectic identity #3: %s', norm(approx_z0))
        logger.info('error in symplectic identity #4: %s', norm(approx_z1))
        okay = True
        if not (abs(det-1.0) < tolerance):
            okay = False
        if not (norm(approx_j - j) < tolerance):
            okay = False
        if not (norm(approx_i - i) < tolerance):
            okay = False
        if not (norm(approx_z0) < tolerance):
            okay = False
        if not (norm(approx_z1) < tolerance):
            okay = False
        return okay
Пример #49
0
def covarianceMatrix(data, normalize = 1):
    npoints, dimension = shape(data)
    if normalize: 
        data = data - Numeric.sum(data)/npoints

    if dimension > npoints:
        return dot(data, Numeric.transpose(data)) / (npoints-1)
        
    return dot(transpose(data), data)/(npoints-1)
Пример #50
0
    def asymmetricalPart(self):
        "Returns the asymmetrical part of a rank-2 tensor."
	if self.rank == 2:
	    return Tensor(0.5*(self.array - \
			       Numeric.transpose(self.array,
						    Numeric.array([1,0]))),
			  1)
	else:
	    raise ValueError, 'Not yet implemented'