コード例 #1
0
ファイル: extruder.py プロジェクト: lisarosalina/App
    def __init__(self,
                 path3D,
                 matrix,
                 shape,
                 cap1=0,
                 cap2=0,
                 arrow=0,
                 larrow=3,
                 warrow=2):
        """
        Constructor: Takes as arguments a path3D, matrix, 2D shape, and
        optional cap1, cap2, and arrow.  Calls getextrudeVertices() and
        getFaces() and stores the return values in self.vertices, self.vnormals
        , and self.faces.
        """
        self.path3D = path3D
        self.matrix = matrix
        self.shape = shape
        self.arrow = arrow
        if not isinstance(self.shape, Rectangle2D):
            self.arrow = 0
        self.larrow = larrow
        self.warrow = warrow
        self.cap1 = cap1
        self.cap2 = cap2
        if self.arrow: self.cap2 = 0  # no end cap if arrow
        self.norms = matrix[:, 0]
        self.vertices, self.vnormals = self.getextrudeVertices()
        self.faces = self.getFaces()

        # Here need to create a numeric array for each properties:
        # colors
        self.colors = Numeric.ones((len(self.faces), 3), 'f')
        # opacities
        self.opacities = Numeric.ones((len(self.faces), ), 'f')
コード例 #2
0
    def __init__(self, path3D, matrix, shape, cap1=0, cap2=0, arrow=0,
                 larrow=3, warrow=2):
        """
        Constructor: Takes as arguments a path3D, matrix, 2D shape, and
        optional cap1, cap2, and arrow.  Calls getextrudeVertices() and
        getFaces() and stores the return values in self.vertices, self.vnormals
        , and self.faces.
        """
        self.path3D = path3D
        self.matrix = matrix
        self.shape = shape
        self.arrow = arrow
        if not isinstance(self.shape, Rectangle2D):
            self.arrow = 0
        self.larrow = larrow
        self.warrow = warrow
        self.cap1 = cap1
        self.cap2 = cap2
        if self.arrow: self.cap2 = 0    # no end cap if arrow
        self.norms = matrix[:,0]
        self.vertices, self.vnormals = self.getextrudeVertices()
        self.faces = self.getFaces()

        # Here need to create a numeric array for each properties:
        # colors
        self.colors = Numeric.ones((len(self.faces), 3),'f')
        # opacities
        self.opacities = Numeric.ones((len(self.faces),),'f')
コード例 #3
0
ファイル: ncoordstest.py プロジェクト: lisarosalina/App
 def test_constructor_shape(self):
     """__init__         -- make refCoords and resultCoords homogeneous"""
     n = len(self.random_points)
     ncoords = Ncoords(self.random_points)  ### tested call ###
     # confirm shape to be nx4
     self.assertEqual((n, 4), Numeric.shape(ncoords.resultCoords))
     self.assertEqual((n, 4), Numeric.shape(ncoords.refCoords))
     # cofirm that the last column is all ones
     self.assertEqual(
         Numeric.ones(n).tolist(), ncoords.resultCoords[:, 3].tolist())
     self.assertEqual(
         Numeric.ones(n).tolist(), ncoords.refCoords[:, 3].tolist())
コード例 #4
0
ファイル: ncoordstest.py プロジェクト: 8848/Pymol-script-repo
 def test_constructor_shape(self):
     """__init__         -- make refCoords and resultCoords homogeneous"""
     n = len(self.random_points)
     ncoords = Ncoords( self.random_points) ### tested call ###
     # confirm shape to be nx4
     self.assertEqual( (n, 4), Numeric.shape(ncoords.resultCoords))
     self.assertEqual( (n, 4), Numeric.shape(ncoords.refCoords))
     # cofirm that the last column is all ones
     self.assertEqual(Numeric.ones(n).tolist(),
                      ncoords.resultCoords[:,3].tolist())
     self.assertEqual(Numeric.ones(n).tolist(),
                      ncoords.refCoords[:,3].tolist())
コード例 #5
0
ファイル: Trajectory.py プロジェクト: ostrokach/biskit
    def residusMaximus(self, atomValues, mask=None):
        """
        Take list of value per atom, return list where all atoms of any
        residue are set to the highest value of any atom in that residue.
        (after applying mask)

        @param atomValues: list 1 x N, values per atom
        @type  atomValues: [ float ]
        @param mask: list 1 x N, 0|1, 'master' atoms of each residue
        @type  mask: [1|0]

        @return: Numpy array 1 x N of float
        @rtype: array
        """
        if mask is None:
            mask = N.ones(len(self.frames[0]), N.int32)

        ## eliminate all values that do not belong to the selected atoms
        masked = atomValues * mask

        result = []

        ## set all atoms of each residue to uniform value
        for res in range(0, self.resMap()[-1] + 1):

            ## get atom entries for this residue
            resAtoms = N.compress(N.equal(self.resMap(), res), masked)

            ## get maximum value
            masterValue = max(resAtoms)

            result += resAtoms * 0.0 + masterValue

        return N.array(result)
コード例 #6
0
    def doit(self, atom1, atom2, angle, mov_atoms, returnVal=0):
        mol = atom1.top
        if mov_atoms is None:
            mov_atoms = mol.subTree(atom1, atom2, mol.allAtoms)
        assert len(mov_atoms)
        mov_coords = Numeric.array(mov_atoms.coords)
        lenCoords = len(mov_coords)
        x = Numeric.array(atom1.coords)
        y = Numeric.array(atom2.coords)
        rot = (angle * 3.14159/180.)%(2 * Numeric.pi)
        matrix = rotax(x, y, rot)
        _ones = Numeric.ones(lenCoords, 'f')
        _ones.shape = (lenCoords,1)
        mov_coords = Numeric.concatenate((mov_coords, _ones),1)
        newcoords = Numeric.dot(mov_coords, matrix)
        nc = newcoords[:,:3].astype('f')
        for i in range(lenCoords):
            at = mov_atoms[i]
            at._coords[at.conformation] = nc[i].tolist()

        event = EditAtomsEvent('coords', mov_atoms)
        self.vf.dispatchEvent(event)

        #have to return nc for setTorsionGC
        if returnVal:
            return nc
コード例 #7
0
ファイル: Displayable.py プロジェクト: lisarosalina/App
    def Reset(self):
        if __debug__:
            if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
        """Reset members to default values"""

        self.pattern = Numeric.ones((128, )) * 0xFF
        self.pattern = self.pattern.astype('B')
コード例 #8
0
    def SetMaterial(self, values, prop=1, tagModified=True):
        """Set the materials
WARNING: when back face colors are set, two sided lighting has to be enabled
        
we set RGB values for all properties except for shininess and opacity
If an alpha value are specified they will be ignored
Since IndexedGeomDSPL requires alpha values for all properties
we set them automatically to 1.0 for all properties except for
diffuse. The alpha channel of the diffuse component will be set later
in fixOpacity which should be called after all properties of the
material have been updated.
"""
        if tagModified:
            self._modified = True

        if prop is None: prop = self.diff
        elif type(prop) is types.StringType:
            prop = getattr(self, prop)

        assert prop in (0, 1, 2, 3, 4, 5)

        values = array(values, 'f')
        if prop < self.shini:
            assert len(values.shape) == 2 and values.shape[1] in [3, 4]
            alpha = ones((values.shape[0], 1), 'f')
            values = concatenate((values[:, :3], alpha), 1)
        else:
            if len(values.shape) != 1:
                values = array([values], 'f')

        self.prop[prop] = values
コード例 #9
0
ファイル: plot.py プロジェクト: jesuscript/TopographicaSVN
  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)
        one=ones(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)
コード例 #10
0
 def smooth(self):
     average = (Numeric.ones((3, 3), 'f') / 9.).astype('f')
     #        average[1][1] = .0
     print average
     self.redraw(filter=average)
     image = (self.imageAsArray()).astype('B')
     return image
コード例 #11
0
ファイル: colorTool.py プロジェクト: lisarosalina/App
def Map(values, colorMap, mini=None, maxi=None):
    """Get colors corresponding to values in a colormap"""

    values = Numeric.array(values)
    if len(values.shape)==2 and values.shape[1]==1:
	values.shape = ( values.shape[0], )
    elif len(values.shape) > 1:
	print 'ERROR: values array has bad shape'
	return None

    cmap = Numeric.array(colorMap)
    if len(cmap.shape) !=2 or cmap.shape[1] not in (3,4):
	print 'ERROR: colorMap array has bad shape'
	return None

    if mini is None: mini = min(values)
    else: values = Numeric.maximum(values, mini)
    if maxi is None: maxi = max(values)
    else: values = Numeric.minimum(values, maxi)
    valrange = maxi-mini
    if valrange < 0.0001:
	ind = Numeric.ones( values.shape )
    else:
	colrange = cmap.shape[0]-1
	ind = ((values-mini) * colrange) / valrange
    col = Numeric.take(colorMap, ind.astype(viewerConst.IPRECISION))
    return col
コード例 #12
0
    def castHmmDic(self, hmmDic, repete, hmmGap, key):
        """
        Blow up hmmDic to the number of repetes of the profile used.
        Correct scores for possible deletions in the search sequence.

        @param hmmDic: dictionary from L{getHmmProfile}
        @type  hmmDic: dict
        @param repete: repete information from L{align}
        @type  repete: int
        @param hmmGap: information about gaps from L{align}
        @type  hmmGap: [int]
        @param key: name of scoring method to adjust for gaps and repetes
        @type  key: str
        
        @return: dictionary with information about the profile
        @rtype: dict        
        """
        s = hmmDic[key]

        for i in range(repete):
            mask = N.ones(len(s))
            N.put(mask, hmmGap[i], 0)
            if i == 0:
                score = N.compress(mask, s, 0)
            if i > 0:
                score = N.concatenate((N.compress(mask, s, 0), score))

        hmmDic[key] = score

        return hmmDic
コード例 #13
0
ファイル: plot.py プロジェクト: ykneisel/topographica
    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)
コード例 #14
0
ファイル: Trajectory.py プロジェクト: ostrokach/biskit
    def residusMaximus( self, atomValues, mask=None ):
        """
        Take list of value per atom, return list where all atoms of any
        residue are set to the highest value of any atom in that residue.
        (after applying mask)

        @param atomValues: list 1 x N, values per atom
        @type  atomValues: [ float ]
        @param mask: list 1 x N, 0|1, 'master' atoms of each residue
        @type  mask: [1|0]

        @return: Numpy array 1 x N of float
        @rtype: array
        """
        if mask is None:
            mask = N.ones( len( self.frames[0] ), N.int32 )

        ## eliminate all values that do not belong to the selected atoms
        masked = atomValues * mask

        result = []

        ## set all atoms of each residue to uniform value
        for res in range( 0, self.resMap()[-1]+1 ):

            ## get atom entries for this residue
            resAtoms = N.compress( N.equal( self.resMap(), res ), masked )

            ## get maximum value
            masterValue = max( resAtoms )

            result += resAtoms * 0.0 + masterValue

        return N.array( result )
コード例 #15
0
ファイル: plot.py プロジェクト: a-l-gee/topographica
    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)
コード例 #16
0
ファイル: colorTool.py プロジェクト: lisarosalina/App
def array2DToImage( array2D, cmap, width=None, 
	height=None, numComponents=4,texture=1, maxi=None, mini=None):
    #build the image:
    if width is None:
        width=array2D.shape[0]
    if height is None:
        height=array2D.shape[1]
    #texture sets the image dimensions to the smallest power of two
    if texture:
        dim1 = dim2=1
        while dim1< width: dim1=dim1<<1
        while dim2< height: dim2=dim2<<1

    colors = Map(array2D.ravel(), cmap,mini=mini, maxi=maxi )

    ###7/19: because these are Numeric arrays???!!!!
    ###7/19colors.shape = (width, height,3)
    colors.shape = (height, width,3)
    colors = colors*255
    colors = colors.astype('B')
    tex2Dimage = Numeric.ones((dim2,dim1,numComponents), 'B')
    ###7/19: because these are Numeric arrays???!!!!
    ###7/19tex2Dimage = Numeric.ones((dim1,dim2,numComponents), 'B')
    ###7/19 tex2Dimage[:width,:height,:3] = colors
    tex2Dimage[:height,:width,:3] = colors
    return tex2Dimage
コード例 #17
0
ファイル: setangleCommands.py プロジェクト: lisarosalina/App
    def doit(self, atom1, atom2, angle, mov_atoms, returnVal=0):
        mol = atom1.top
        if mov_atoms is None:
            mov_atoms = mol.subTree(atom1, atom2, mol.allAtoms)
        assert len(mov_atoms)
        mov_coords = Numeric.array(mov_atoms.coords)
        lenCoords = len(mov_coords)
        x = Numeric.array(atom1.coords)
        y = Numeric.array(atom2.coords)
        rot = (angle * 3.14159 / 180.) % (2 * Numeric.pi)
        matrix = rotax(x, y, rot)
        _ones = Numeric.ones(lenCoords, 'f')
        _ones.shape = (lenCoords, 1)
        mov_coords = Numeric.concatenate((mov_coords, _ones), 1)
        newcoords = Numeric.dot(mov_coords, matrix)
        nc = newcoords[:, :3].astype('f')
        for i in range(lenCoords):
            at = mov_atoms[i]
            at._coords[at.conformation] = nc[i].tolist()

        event = EditAtomsEvent('coords', mov_atoms)
        self.vf.dispatchEvent(event)

        #have to return nc for setTorsionGC
        if returnVal:
            return nc
コード例 #18
0
ファイル: numpyExtn.py プロジェクト: www3838438/orange-bio
def triangularPut(m1d, upper=1, lower=0):
    """Returns 2D masked array with elements of the given 1D array in the strictly upper (lower) triangle.
    Elements of the 1D array should be ordered according to the upper triangular part of the 2D matrix.
    The lower triangular part (if requested) equals to the transposed upper triangular part.
    If upper == lower == 1 a symetric matrix is returned.
    """
    assert upper in [0,1] and lower in [0,1], "[0|1] expected for upper / lower"
    m1d = MA.asarray(m1d)
    assert MA.rank(m1d) == 1, "1D masked array expected"
    m2dShape0 = math.ceil(math.sqrt(2*m1d.shape[0]))
    assert m1d.shape[0] == m2dShape0*(m2dShape0-1)/2, "the length of m1d does not correspond to n(n-1)/2"
    if upper:
        if lower:
            mask = Numeric.fromfunction(lambda i,j: i==j, (m2dShape0, m2dShape0))
        else:
            mask = Numeric.fromfunction(lambda i,j: i>=j, (m2dShape0, m2dShape0))
    else:
        if lower:
            mask = Numeric.fromfunction(lambda i,j: i<=j, (m2dShape0, m2dShape0))
        else:
            mask = Numeric.ones((m2dShape0, m2dShape0))

    m2d = MA.ravel(MA.zeros((m2dShape0, m2dShape0), m1d.dtype.char))
    condUpperTriang = Numeric.fromfunction(lambda i,j: i<j, (m2dShape0, m2dShape0))
    putIndices = Numeric.compress(Numeric.ravel(condUpperTriang), Numeric.arange(0, m2dShape0**2, typecode=Numeric.Int))
    MA.put(m2d, putIndices, m1d)
    m2d = MA.reshape(m2d, (m2dShape0, m2dShape0))
    m2d = MA.where(condUpperTriang, m2d, MA.transpose(m2d))
    return MA.array(m2d, mask=Numeric.logical_or(mask, MA.getmaskarray(m2d)))
コード例 #19
0
    def shuffledLists(self, n, lst, mask=None):
        """
        shuffle order of a list n times, leaving masked(0) elements untouched

        @param n: number of times to shuffle the list
        @type  n: int
        @param lst: list to shuffle
        @type  lst: [any]
        @param mask: mask to be applied to lst
        @type  mask: [1|0]

        @return: list of shuffeled lists
        @rtype: [[any]]        
        """
        if not mask:
            mask = N.ones(len(lst))

        if type(lst) == list:
            lst = N.array(lst)

        pos = N.nonzero(mask)

        rand_pos = N.array([self.__shuffleList(pos) for i in range(n)])

        result = []
        for p in rand_pos:

            r = copy.copy(lst)
            N.put(r, p, N.take(lst, pos))
            result += [r]

        return result
コード例 #20
0
def test_booleans():
    # numpy doesn't let you do boolean tests on arrays.  Use a.all() instead
    a = N.ones(5)

    assert_raises(ValueError, lambda: not a)

    assert_true(a.all())
コード例 #21
0
ファイル: Analyzer.py プロジェクト: ostrokach/biskit
    def shuffledLists( self, n, lst, mask=None ):
        """
        shuffle order of a list n times, leaving masked(0) elements untouched

        @param n: number of times to shuffle the list
        @type  n: int
        @param lst: list to shuffle
        @type  lst: [any]
        @param mask: mask to be applied to lst
        @type  mask: [1|0]

        @return: list of shuffeled lists
        @rtype: [[any]]        
        """
        if not mask:
            mask = N.ones( len(lst)  )

        if type( lst ) == list:
            lst = N.array( lst )
        
        pos = N.nonzero( mask )

        rand_pos = N.array( [ self.__shuffleList( pos ) for i in range(n) ] )

        result = []
        for p in rand_pos:

            r = copy.copy( lst )
            N.put( r, p, N.take( lst, pos ) )
            result += [r]

        return result
コード例 #22
0
ファイル: Hmmer.py プロジェクト: ostrokach/biskit
    def castHmmDic( self, hmmDic, repete, hmmGap, key ):
        """
        Blow up hmmDic to the number of repetes of the profile used.
        Correct scores for possible deletions in the search sequence.

        @param hmmDic: dictionary from L{getHmmProfile}
        @type  hmmDic: dict
        @param repete: repete information from L{align}
        @type  repete: int
        @param hmmGap: information about gaps from L{align}
        @type  hmmGap: [int]
        @param key: name of scoring method to adjust for gaps and repetes
        @type  key: str
        
        @return: dictionary with information about the profile
        @rtype: dict        
        """
        s = hmmDic[key]

        for i in range( repete ):
            mask = N.ones( len(s) )
            N.put( mask, hmmGap[i], 0 )
            if i == 0:
                score = N.compress( mask, s, 0 )
            if i > 0:
                score = N.concatenate( ( N.compress( mask, s, 0 ), score ) )

        hmmDic[key] = score

        return hmmDic
コード例 #23
0
ファイル: Clip.py プロジェクト: lisarosalina/App
    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)
コード例 #24
0
ファイル: ReduceCoordinates.py プロジェクト: ostrokach/biskit
    def group( self, a_indices, maxPerCenter ):
        """
        Group a bunch of integers (atom indices in PDBModel) so that each
        group has at most maxPerCenter items.
        
        @param a_indices: atom indices
        @type  a_indices: [int]
        @param maxPerCenter: max entries per group
        @type  maxPerCenter: int
        
        @return: list of lists of int
        @rtype: [[int],[int]..]
        """
        ## how many groups are necessary?
        n_centers = len( a_indices ) / maxPerCenter
        if len( a_indices ) % maxPerCenter:
            n_centers += 1

        ## how many items/atoms go into each group?
        nAtoms = N.ones(n_centers, N.Int) * int(len( a_indices ) / n_centers)
        i=0
        while N.sum(nAtoms) != len( a_indices ):
            nAtoms[i] += 1
            i += 1

        ## distribute atom indices into groups
        result = []
        pos = 0
        for n in nAtoms:
            result += [ N.take( a_indices, N.arange(n) + pos) ]
            pos += n

        return result
コード例 #25
0
ファイル: Srf.py プロジェクト: adocherty/polymode
 def __init__(self, cntrl, uknots, vknots):
     self._bezier = None
     cntrl = numerix.asarray(cntrl, numerix.Float)
     (dim, nu, nv) = cntrl.shape
     if dim < 2 or dim > 4:
         raise NURBSError, 'Illegal control point format'
     elif dim < 4:
         self.cntrl = numerix.zeros((4, nu, nv), numerix.Float)
         self.cntrl[0:dim,:,:] = cntrl
         self.cntrl[-1,:,:] = numerix.ones((nu,nv), numerix.Float)
     else:
         self.cntrl = cntrl
         
     # Force the u knot sequence to be a vector in ascending order
     # and normalise between [0.0,1.0]
     uknots = numerix.sort(numerix.asarray(uknots, numerix.Float))
     nku = uknots.shape[0]
     uknots = (uknots - uknots[0])/(uknots[-1] - uknots[0])
     if uknots[0] == uknots[-1]:
         raise NURBSError, 'Illegal uknots sequence'
     self.uknots = uknots
     
     # Force the v knot sequence to be a vector in ascending order
     # and normalise between [0.0,1.0]  
     vknots = -numerix.sort(-numerix.asarray(vknots, numerix.Float))
     nkv = vknots.shape[0]
     vknots = (vknots - vknots[0])/(vknots[-1] - vknots[0])
     if vknots[0] == vknots[-1]:
         raise NURBSError, 'Illegal vknots sequence'
     self.vknots = vknots
     
     # Spline Degree
     self.degree = [nku-nu-1, nkv-nv-1]
     if self.degree[0] < 0 or self.degree[1] < 0:
         raise NURBSError, 'NURBS order must be a positive integer'
コード例 #26
0
ファイル: PDBDope.py プロジェクト: ostrokach/biskit
    def addDensity( self, radius=6, minasa=None, profName='density' ):
        """
        Count the number of heavy atoms within the given radius.
        Values are only collected for atoms with |minasa| accessible surface
        area.

        @param minasa: relative exposed surface - 0 to 100%
        @type  minasa: float
        @param radius: in Angstrom
        @type  radius: float
        """
        mHeavy = self.m.maskHeavy()

        xyz = N.compress( mHeavy, self.m.getXyz(), 0 )

        if minasa and self.m.profile( 'relAS', 0 ) == 0:
            self.addASA()

        if minasa:
            mSurf = self.m.profile2mask( 'relAS', minasa )
        else:
            mSurf = N.ones( self.m.lenAtoms() )

        ## loop over all surface atoms
        surf_pos = N.nonzero( mSurf )
        contacts = []

        for i in surf_pos:
            dist = N.sum(( xyz - self.m.xyz[i])**2, 1)
            contacts += [ N.sum( N.less(dist, radius**2 )) -1]

        self.m.atoms.set( profName, contacts, mSurf, default=-1,
                          comment='atom density radius %3.1fA' % radius,
                          version= T.dateString() + ' ' + self.version() )
コード例 #27
0
    def Reset(self):
        if __debug__:
         if hasattr(DejaVu, 'functionName'): DejaVu.functionName()
	"""Reset members to default values"""

	self.pattern = Numeric.ones( (128,)) * 0xFF
	self.pattern = self.pattern.astype('B')
コード例 #28
0
    def doit(self, mobAtoms):
        """
mobAtoms: AtomSet that is being frozen.
Assuming the AtomSet are from same molecule
        """

        # fixme: need checking for mat (matrix) and mobAtoms
        geomContainer = mobAtoms[0].top.geomContainer
        mGeom = geomContainer.masterGeom
        mat = mGeom.rotation
        mat = Numeric.reshape(mat, (4, 4))

        # update coords
        mobAtoms = mobAtoms.findType(Atom)
        coords = mobAtoms.coords
        hCoords = Numeric.concatenate((coords,Numeric.ones((len(coords),1),\
                                                            'd')), 1)
        tCoords = Numeric.dot(hCoords, mat)[:, :3]
        tCoords = tCoords.tolist()
        mobAtoms.updateCoords(tCoords, 0)  # overwritten the original coords

        # reset the rotation matrix of masterGeom
        identity = Numeric.identity(4, 'f').ravel()
        mGeom.SetRotation(Numeric.identity(4, 'f').ravel())

        event = EditAtomsEvent('coords', mobAtoms)
        self.vf.dispatchEvent(event)

        mGeom.viewer.Redraw()

        return
コード例 #29
0
    def doit(self,mobAtoms):
        """
mobAtoms: AtomSet that is being frozen.
Assuming the AtomSet are from same molecule
        """

        # fixme: need checking for mat (matrix) and mobAtoms
        geomContainer = mobAtoms[0].top.geomContainer
        mGeom = geomContainer.masterGeom
        mat = mGeom.rotation
        mat = Numeric.reshape(mat, (4,4))

        # update coords
        mobAtoms = mobAtoms.findType(Atom)
        coords = mobAtoms.coords
        hCoords = Numeric.concatenate((coords,Numeric.ones((len(coords),1),\
                                                            'd')), 1)
        tCoords = Numeric.dot(hCoords, mat)[:,:3]
        tCoords = tCoords.tolist()
        mobAtoms.updateCoords(tCoords, 0) # overwritten the original coords
        
        # reset the rotation matrix of masterGeom
        identity = Numeric.identity(4,'f').ravel()
        mGeom.SetRotation(Numeric.identity(4,'f').ravel() ) 

        event = EditAtomsEvent('coords', mobAtoms)
        self.vf.dispatchEvent(event)
        
        mGeom.viewer.Redraw()
        
        return
コード例 #30
0
ファイル: ReduceCoordinates.py プロジェクト: ostrokach/biskit
    def group(self, a_indices, maxPerCenter):
        """
        Group a bunch of integers (atom indices in PDBModel) so that each
        group has at most maxPerCenter items.
        
        @param a_indices: atom indices
        @type  a_indices: [int]
        @param maxPerCenter: max entries per group
        @type  maxPerCenter: int
        
        @return: list of lists of int
        @rtype: [[int],[int]..]
        """
        ## how many groups are necessary?
        n_centers = len(a_indices) / maxPerCenter
        if len(a_indices) % maxPerCenter:
            n_centers += 1

        ## how many items/atoms go into each group?
        nAtoms = N.ones(n_centers, N.Int) * int(len(a_indices) / n_centers)
        i = 0
        while N.sum(nAtoms) != len(a_indices):
            nAtoms[i] += 1
            i += 1

        ## distribute atom indices into groups
        result = []
        pos = 0
        for n in nAtoms:
            result += [N.take(a_indices, N.arange(n) + pos)]
            pos += n

        return result
コード例 #31
0
ファイル: Srf.py プロジェクト: uceearq/polymode-1
    def __init__(self, cntrl, uknots, vknots):
        self._bezier = None
        cntrl = numerix.asarray(cntrl, numerix.Float)
        (dim, nu, nv) = cntrl.shape
        if dim < 2 or dim > 4:
            raise NURBSError, 'Illegal control point format'
        elif dim < 4:
            self.cntrl = numerix.zeros((4, nu, nv), numerix.Float)
            self.cntrl[0:dim, :, :] = cntrl
            self.cntrl[-1, :, :] = numerix.ones((nu, nv), numerix.Float)
        else:
            self.cntrl = cntrl

        # Force the u knot sequence to be a vector in ascending order
        # and normalise between [0.0,1.0]
        uknots = numerix.sort(numerix.asarray(uknots, numerix.Float))
        nku = uknots.shape[0]
        uknots = (uknots - uknots[0]) / (uknots[-1] - uknots[0])
        if uknots[0] == uknots[-1]:
            raise NURBSError, 'Illegal uknots sequence'
        self.uknots = uknots

        # Force the v knot sequence to be a vector in ascending order
        # and normalise between [0.0,1.0]
        vknots = -numerix.sort(-numerix.asarray(vknots, numerix.Float))
        nkv = vknots.shape[0]
        vknots = (vknots - vknots[0]) / (vknots[-1] - vknots[0])
        if vknots[0] == vknots[-1]:
            raise NURBSError, 'Illegal vknots sequence'
        self.vknots = vknots

        # Spline Degree
        self.degree = [nku - nu - 1, nkv - nv - 1]
        if self.degree[0] < 0 or self.degree[1] < 0:
            raise NURBSError, 'NURBS order must be a positive integer'
コード例 #32
0
    def smooth(self):
        average = (Numeric.ones( (3,3) , 'f')/9.).astype('f')
#        average[1][1] = .0
        print average
        self.redraw(filter=average)
        image = (self.imageAsArray()).astype('B')
        return image
コード例 #33
0
ファイル: TrajCluster.py プロジェクト: ostrokach/biskit
    def cluster( self, n_clusters, weight=1.13, converged=1e-11,
                 aMask=None, force=0 ):
        """
        Calculate new clusters.

        @param n_clusters: number of clusters
        @type  n_clusters: int
        @param weight: fuzziness weigth
        @type  weight: float (default: 1.13)
        @param converged: stop iteration if min dist changes less than
                          converged (default: 1e-11)
        @type  converged: float
        @param aMask: atom mask applied before clustering
        @type  aMask: [1|0]
        @param force: re-calculate even if parameters haven't changed
                      (default:0)
        @type  force: 1|0
        """
        if aMask == None:
            aMask = N.ones( self.traj.getRef().lenAtoms() )

        if self.fc == None or force or self.fcWeight != weight \
           or self.n_clusters != n_clusters or N.any( self.aMask != aMask) \
           or self.fcConverged != converged:

            self.n_clusters = n_clusters
            self.fcWeight = weight
            self.aMask = aMask

            self.fc = FuzzyCluster( self.__raveled(), self.n_clusters,
                                    self.fcWeight )

            self.fcCenters = self.fc.go( self.fcConverged,
                                         1000, nstep=10,
                                         verbose=self.verbose )
コード例 #34
0
    def SetMaterial(self, values, prop=1, tagModified=True):
	"""Set the materials
WARNING: when back face colors are set, two sided lighting has to be enabled
        
we set RGB values for all properties except for shininess and opacity
If an alpha value are specified they will be ignored
Since IndexedGeomDSPL requires alpha values for all properties
we set them automatically to 1.0 for all properties except for
diffuse. The alpha channel of the diffuse component will be set later
in fixOpacity which should be called after all properties of the
material have been updated.
"""
        if tagModified:
            self._modified = True

        if prop is None: prop = self.diff
        elif type(prop) is types.StringType:
            prop = getattr(self, prop)

        assert prop in (0,1,2,3,4,5)

        values = array( values, 'f' )
	if prop < self.shini:
            assert len(values.shape)==2 and values.shape[1] in [3,4]
            alpha = ones( (values.shape[0], 1), 'f' )
            values = concatenate( (values[:,:3], alpha), 1 )
        else:
            if len(values.shape) != 1:
                values = array([values], 'f' )
            
        self.prop[prop] = values
コード例 #35
0
ファイル: Util.py プロジェクト: uceearq/polymode-1
def scale(sxyz):
    ret = numerix.identity(4).astype(numerix.Float)
    s = numerix.ones(3, numerix.Float)
    s[0:len(sxyz)] = sxyz
    ret[0, 0] = s[0]
    ret[1, 1] = s[1]
    ret[2, 2] = s[2]
    return ret
コード例 #36
0
 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.])
コード例 #37
0
ファイル: match2seq.py プロジェクト: ostrokach/biskit
def del2mask(seq, *delpos):
    """convert list of (from, to) delete positions into a mask of 0 or 1"""
    mask = N.ones(len(seq))

    for start, size in delpos:
        mask.put(range(start, start + size), 0)

    return mask
コード例 #38
0
ファイル: distanceSelector.py プロジェクト: lisarosalina/App
 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])
コード例 #39
0
ファイル: match2seq.py プロジェクト: ostrokach/biskit
def del2mask( seq, *delpos ):
    """convert list of (from, to) delete positions into a mask of 0 or 1"""
    mask = N.ones( len(seq) )

    for start, size in delpos:
        mask.put( range( start, start+size), 0 )
        
    return mask
コード例 #40
0
ファイル: Srf.py プロジェクト: adocherty/polymode
 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.])
コード例 #41
0
ファイル: Util.py プロジェクト: Germanc/supreme
def scale(sxyz):
    ret = numerix.identity(4).astype(numerix.Float)
    s = numerix.ones(3, numerix.Float)
    s[0:len(sxyz)] = sxyz
    ret[0,0] = s[0]
    ret[1,1] = s[1]
    ret[2,2] = s[2]
    return ret
コード例 #42
0
    def End(self):
        import math

        # center the points around the origin
        sca = (1.0 / self.griddingSize) * self.gridToWorld
        points = Numeric.array(self.shape, 'f') * sca
        xsum, ysum = 0, 0
        if points:
            repeat = 0
            comp = points[-1] - points[0]
            if abs(comp[0]) < .01 and abs(comp[1]) < .01: repeat = -1
            for i in range(len(points) + repeat):
                xsum = xsum + points[i][0]
                ysum = ysum + points[i][1]
            xcenter = xsum / (len(points) + repeat)
            ycenter = ysum / (len(points) + repeat)
            origin = (xcenter, ycenter)
            points = points - origin
            points[:, 1:] = points[:, 1:] * -1

            # 3D
            o = Numeric.ones((len(points), 1))
            points = Numeric.concatenate((points, o), 1)

            # calculate normals to each side
            normals = Numeric.zeros((len(points) - 1, 3), 'f')
            for i in range(len(points) - 1):
                diff = points[i + 1] - points[i]
                if diff[1] == 0:
                    normals[i][0] = 0.0
                    normals[i][1] = diff[0] / abs(diff[0])
                else:
                    slope = -diff[0] / diff[1]
                    size = -math.sqrt(1 + slope**2) * (diff[1] / abs(diff[1]))
                    normals[i][0] = 1.0 / size
                    normals[i][1] = slope / size

            # duplicate vertices
            if self.dup.get():
                pts = Numeric.concatenate((points, points), 1)
                self.points = Numeric.reshape(pts, (2 * len(points), 3))
                norms1 = Numeric.concatenate(
                    (Numeric.reshape(normals[-1], (1, 3)), normals))
                norms2 = Numeric.concatenate(
                    (normals, Numeric.reshape(normals[0], (1, 3))))
                norms = Numeric.concatenate((norms1, norms2), 1)
                self.normals = Numeric.reshape(norms, (2 * len(points), 3))
            # single vertices: average normals
            else:
                self.points = points
                self.normals = Numeric.zeros((len(points), 3)).astype('f')
                for i in range(len(points) - 1):
                    n = (normals[i - 1] + normals[i]) / 2
                    self.normals[i] = n.astype('f')
                self.normals[len(points) - 1] = self.normals[0]
            print self.points
        else:
            self.points, self.normals = [], []
コード例 #43
0
ファイル: OWHypTest.py プロジェクト: acopar/orange-bio
    def runANOVA(self):
        """converts structured data [(name, [orngET1, orngET2, ...]),...] to a 3D masked array
        with the following axes: 0: examples, 1: variables, 2: ExampleTables;
        runs ANOVA computations and sets self.ps;
        """
        if self.dataStructure and self.numExamples > 0:
            ma3d = MA.zeros((self.numExamples, self.numVariables, reduce(lambda a,b: a+len(b[1]), self.dataStructure, 0)), Numeric.Float) * MA.masked
            groupLens = []
            etIdx = 0
            for dsName, etList in self.dataStructure:
                for et in etList:
                    ma3d[:,:,etIdx] = et.toNumpyMA("ac")[0]
                    etIdx += 1
                groupLens.append(len(etList))
            # run ANOVA
            self.infoc.setText('ANOVA computation started...')
            self.progressBarInit()
            pbStep = 100./self.numExamples
            self.ps = Numeric.ones((3, self.numExamples), Numeric.Float)

            if self.anovaType == OWHypTest.St2AB or self.anovaType == OWHypTest.St2ABI:
                ps = self.anova2(ma3d, groupLens, addInteraction=self.anovaType==OWHypTest.St2ABI, repMeasuresOnA=False, callback=lambda: self.progressBarAdvance(pbStep))
                for rIdx in range(ps.shape[0]):
                    self.ps[rIdx] = ps[rIdx]

            elif self.anovaType == OWHypTest.St1B:
                self.ps[1] = self.anova1B(ma3d, groupLens, repMeasures=False, callback=lambda: self.progressBarAdvance(pbStep))

            elif self.anovaType == OWHypTest.St1A:
                self.ps[0] = self.anova1A(ma3d, repMeasures=False, callback=lambda: self.progressBarAdvance(pbStep))

            elif self.anovaType == OWHypTest.StSST:
                try:
                    popMeanVal = float(self.popMean)
                except ValueError:
                    print "Warning: cannot convert %s to float, using 0" % str(self.popMean)
                    self.popMean = 0
                    popMeanVal = 0
                self.ps[0] = self.ttest_ssmpl(ma3d, popMeanVal, callback=lambda: self.progressBarAdvance(pbStep))

            elif self.anovaType == OWHypTest.StLPE:
               raise Exception, "NOT IMPLEMENTED"
               if self.numVariables == 2:
                  self.ps[0] = self.lpeA(ma3d, callback=lambda: self.progressBarAdvance(pbStep))
               elif self.numVariables == 1:
                  self.ps[1] = self.lpeB(ma3d, groupLens, callback=lambda: self.progressBarAdvance(pbStep))
               else:
                  raise RuntimeError, "%s: expected 2 variables and 1 group, or 1 variable and 2 groups, got %s variables and %s groups" % (OWHypTest.StNames[self.anovaType], self.numVariables, len(groupLens))

            elif self.anovaType == OWHypTest.StRST:
               if self.numVariables == 2 and len(groupLens) == 1:
                  self.ps[0] = self.ttest_rsmplA(ma3d, callback=lambda: self.progressBarAdvance(pbStep))
               elif self.numVariables == 1 and len(groupLens) == 2 and groupLens[0] == groupLens[1]:
                  self.ps[1] = self.ttest_rsmplB(ma3d, groupLens, callback=lambda: self.progressBarAdvance(pbStep))
               else:
                  raise RuntimeError, "%s: expected 2 variables and 1 group, or 1 variable and 2 groups of equal length, got %s variables and %s groups of length %s" % (OWHypTest.StNames[self.anovaType], self.numVariables, len(groupLens), str(groupLens))
                  
            self.progressBarFinished()
コード例 #44
0
    def random_contacts(self, contMat, n, maskRec=None, maskLig=None):
        """
        Create randomized surface contact matrix with same number of
        contacts and same shape as given contact matrix.
        
        @param contMat: template contact matrix
        @type  contMat: matrix
        @param n: number of matrices to generate
        @type  n: int
        @param maskRec: surface masks (or something similar)
        @type  maskRec: [1|0]
        @param maskLig: surface masks (or something similar)
        @type  maskLig: [1|0]
        
        @return: list of [n] random contact matricies
        @rtype: [matrix]
        """
        a, b = N.shape(contMat)
        nContacts = N.sum(N.sum(contMat))

        if not maskLig:
            r_size, l_size = N.shape(contMat)
            maskLig = N.ones(l_size)
            maskRec = N.ones(r_size)

        c_mask = N.ravel(N.outerproduct(maskRec, maskLig))
        c_pos = N.nonzero(c_mask)

        # get array with surface positions from complex
        cont = N.take(N.ravel(contMat), c_pos)
        length = len(cont)

        result = []

        for i in range(n):
            # create random array
            ranCont = mathUtils.randomMask(nContacts, length)

            # blow up to size of original matrix
            r = N.zeros(a * b)
            N.put(r, c_pos, ranCont)

            result += [N.reshape(r, (a, b))]

        return result
コード例 #45
0
ファイル: OWHypTest.py プロジェクト: acopar/orange-bio
 def anova2(self, ma3d, groupLens, addInteraction, repMeasuresOnA, callback):
     """Conducts two-way ANOVA on individual examples;
     returns a Numeric array of p-values in shape (2, numExamples) or (3, numExamples), depending whether we test for interaction;
     Note: levels of factors A and B that cause empty cells are removed prior to conducting ANOVA.
     """
     groupLens = Numeric.asarray(groupLens)
     # arrays to store p-vals
     if addInteraction:
         ps = Numeric.ones((3, ma3d.shape[0]), Numeric.Float)
     else:
         ps = Numeric.ones((2, ma3d.shape[0]), Numeric.Float)
     # decide between non-repeated / repeated measures ANOVA for factor time
     if repMeasuresOnA:
         fAnova = Anova.AnovaRM12LR
     else:
         fAnova = Anova.Anova2wayLR
     # check for empty cells for all genes at once and remove them
     tInd2rem = []
     ax2Ind = Numeric.concatenate(([0], Numeric.add.accumulate(groupLens)))
     for aIdx in range(ma3d.shape[1]):
         for rIdx in range(groupLens.shape[0]):
             if Numeric.add.reduce(MA.count(ma3d[:,aIdx,ax2Ind[rIdx]:ax2Ind[rIdx+1]],1)) == 0:
                 tInd2rem.append(aIdx)
                 break
     if len(tInd2rem) > 0:
         print "Warning: removing time indices %s for all genes" % (str(tInd2rem))
         tInd2keep = range(ma3d.shape[1])
         for aIdx in tInd2rem:
             tInd2keep.remove(aIdx)
         ma3d = ma3d.take(tInd2keep, 1)
     # for each gene...
     for eIdx in range(ma3d.shape[0]):
         # faster check for empty cells for that gene -> remove time indices with empty cells
         ma2d = ma3d[eIdx]
         cellCount = MA.zeros((ma2d.shape[0], groupLens.shape[0]), Numeric.Int)
         for g,(i0,i1) in enumerate(zip(ax2Ind[:-1], ax2Ind[1:])):
             cellCount[:,g] = MA.count(ma2d[:,i0:i1], 1)
         ma2dTakeInd = Numeric.logical_not(Numeric.add.reduce(Numeric.equal(cellCount,0),1)) # 1 where to take, 0 where not to take
         if Numeric.add.reduce(ma2dTakeInd) != ma2dTakeInd.shape[0]:
             print "Warning: removing time indices %s for gene %i" % (str(Numeric.compress(ma2dTakeInd == 0, Numeric.arange(ma2dTakeInd.shape[0]))), eIdx)
             ma2d = MA.compress(ma2dTakeInd, ma2d, 0)
         an = fAnova(ma2d, groupLens, addInteraction, allowReductA=True, allowReductB=True)
         ps[:,eIdx] = an.ps
         callback()
     return ps
コード例 #46
0
ファイル: Analyzer.py プロジェクト: ostrokach/biskit
    def random_contacts( self, contMat, n, maskRec=None, maskLig=None ):
        """
        Create randomized surface contact matrix with same number of
        contacts and same shape as given contact matrix.
        
        @param contMat: template contact matrix
        @type  contMat: matrix
        @param n: number of matrices to generate
        @type  n: int
        @param maskRec: surface masks (or something similar)
        @type  maskRec: [1|0]
        @param maskLig: surface masks (or something similar)
        @type  maskLig: [1|0]
        
        @return: list of [n] random contact matricies
        @rtype: [matrix]
        """
        a,b = N.shape( contMat )
        nContacts = N.sum( N.sum( contMat ))

        if not maskLig:
            r_size, l_size = N.shape( contMat )
            maskLig = N.ones( l_size )
            maskRec = N.ones( r_size )

        c_mask = N.ravel( N.outerproduct( maskRec, maskLig ) )
        c_pos = N.nonzero( c_mask )

        # get array with surface positions from complex
        cont = N.take( N.ravel(contMat), c_pos )
        length = len( cont )

        result = []

        for i in range( n ):
            # create random array
            ranCont = mathUtils.randomMask( nContacts,length )

            # blow up to size of original matrix
            r = N.zeros(a*b)
            N.put( r, c_pos, ranCont)

            result += [ N.reshape( r, (a,b) ) ]

        return result
コード例 #47
0
    def Map(self, values, mini='not passed', maxi='not passed'):
        """Get colors corresponding to values in a colormap.
if mini or maxi are provided, self.mini and self.maxi are not
used and stay inchanged.
if mini or maxi are not provided or set to None, 
self.mini and self.maxi are used instead.
if mini or maxi are set to None, self.mini and self.maxi are
ignored
"""
        #print "Map", mini, maxi, self.mini, self.maxi, values
        values = Numeric.array(values)

        if len(values.shape)==2 and values.shape[1]==1:
            values.shape = ( values.shape[0], )
        elif len(values.shape) > 1:
            raise ValueError('ERROR! values array has bad shape')

        ramp = Numeric.array(self.ramp)
        if len(ramp.shape) !=2 or ramp.shape[1] not in (3,4):
            raise ValueError('ERROR! colormap array has bad shape')

        if mini == 'not passed':
             mini = self.mini
        if maxi == 'not passed':
             maxi = self.maxi

        if mini is None:
            mini = min(values)
        else:
            # All the values < mini will be set to mini
            values = Numeric.maximum(values, mini)
            
        if maxi is None:
            maxi = max(values)
        else:
            values = Numeric.minimum(values, maxi)       

        # mini and maxi are now set
        if mini >= maxi:
            txt = 'mini:%f must be < maxi:%f'%(mini, maxi)
            warnings.warn( txt )

        valrange = maxi - mini
        if valrange < 0.0001:
            ind = Numeric.ones( values.shape )
        else:
            colrange = ramp.shape[0]
            ind = (values - mini) * (colrange/float(valrange))
            ind = ind.astype(viewerConst.IPRECISION)
            ind = Numeric.minimum(ind, colrange - 1)

        col = Numeric.take(self.ramp, ind )
        
        self.lastMini = mini
        self.lastMaxi = maxi

        return col
コード例 #48
0
ファイル: colorMap.py プロジェクト: lisarosalina/App
    def Map(self, values, mini='not passed', maxi='not passed'):
        """Get colors corresponding to values in a colormap.
if mini or maxi are provided, self.mini and self.maxi are not
used and stay inchanged.
if mini or maxi are not provided or set to None, 
self.mini and self.maxi are used instead.
if mini or maxi are set to None, self.mini and self.maxi are
ignored
"""
        #print "Map", mini, maxi, self.mini, self.maxi, values
        values = Numeric.array(values)

        if len(values.shape) == 2 and values.shape[1] == 1:
            values.shape = (values.shape[0], )
        elif len(values.shape) > 1:
            raise ValueError('ERROR! values array has bad shape')

        ramp = Numeric.array(self.ramp)
        if len(ramp.shape) != 2 or ramp.shape[1] not in (3, 4):
            raise ValueError('ERROR! colormap array has bad shape')

        if mini == 'not passed':
            mini = self.mini
        if maxi == 'not passed':
            maxi = self.maxi

        if mini is None:
            mini = min(values)
        else:
            # All the values < mini will be set to mini
            values = Numeric.maximum(values, mini)

        if maxi is None:
            maxi = max(values)
        else:
            values = Numeric.minimum(values, maxi)

        # mini and maxi are now set
        if mini >= maxi:
            txt = 'mini:%f must be < maxi:%f' % (mini, maxi)
            warnings.warn(txt)

        valrange = maxi - mini
        if valrange < 0.0001:
            ind = Numeric.ones(values.shape)
        else:
            colrange = ramp.shape[0]
            ind = (values - mini) * (colrange / float(valrange))
            ind = ind.astype(viewerConst.IPRECISION)
            ind = Numeric.minimum(ind, colrange - 1)

        col = Numeric.take(self.ramp, ind)

        self.lastMini = mini
        self.lastMaxi = maxi

        return col
コード例 #49
0
ファイル: ThreeDeeMath.py プロジェクト: Complex501/visionegg
def make_homogeneous_coord_rows(v):
    """Convert vertex (or row-wise vertices) into homogeneous coordinates."""
    v = Numeric.array(v,typecode=Numeric.Float) # copy
    if len(v.shape) == 1:
        v = v[Numeric.NewAxis,:] # make a rank-2 array
    if v.shape[1] == 3:
        ws = Numeric.ones((v.shape[0],1),typecode=Numeric.Float)
        v = Numeric.concatenate( (v,ws), axis=1 )
    return v
コード例 #50
0
def sizedict(types):
    lst = []
    for type in types:
        lst.append((Numeric.ones(1, type).itemsize, type))
    lst.sort()
    result = {}
    for sz, typ in lst:
        if not result.has_key(sz):
            result[sz] = typ
    return result
コード例 #51
0
ファイル: util.py プロジェクト: MolecularFlipbook/FlipbookApp
def sizedict( types):
    lst = []
    for type in types:
        lst.append((Numeric.ones(1, type).itemsize, type))
    lst.sort()
    result = {}
    for sz, typ in lst:
        if not result.has_key( sz):
            result[ sz] = typ
    return result
コード例 #52
0
ファイル: OWHypTest.py プロジェクト: acopar/orange-bio
 def onDataInput(self, structuredData):
     """handles input data; sets self.dataStructure, self.numExamples, self.numVariables and self.ps;
     updates info, calls updateAnovaTypeBox(), runs ANOVA and sends out new data.
     """
     self.dataStructure = structuredData
     self.numExamples = 0
     self.numVariables = 0
     self.ps = Numeric.ones((3,0), Numeric.Float)
     if structuredData:
         numFiles = reduce(lambda a,b: a+len(b[1]), structuredData, 0)
         lenSD = len(structuredData)
         self.infoa.setText("%d set%s, total of %d data file%s." % (lenSD, ["","s"][lenSD!=1], numFiles, ["","s"][numFiles!=1]))
         numExamplesList = []
         numVariablesList = []
         # construct a list of ExampleTable lengths and a list of number of variables
         for (name, etList) in structuredData:
             for et in etList:
                 numExamplesList.append(len(et))
                 numVariablesList.append(len(et.domain.variables))
         # test that all ExampleTables consist of equal number of examples and variables
         if len(numExamplesList) == 0 or Numeric.add.reduce(Numeric.equal(numExamplesList, numExamplesList[0])) != len(numExamplesList):
             self.dataStructure = None
             self.numExamples = -1
             self.infob.setText("Error: data files contain unequal number of examples, aborting ANOVA computation.")
             self.infoc.setText('')
         elif len(numVariablesList) == 0 or Numeric.add.reduce(Numeric.equal(numVariablesList, numVariablesList[0])) != len(numVariablesList):
             self.dataStructure = None
             self.numVariables = -1
             self.infob.setText("Error: data files contain unequal number of variables, aborting ANOVA computation.")
             self.infoc.setText('')
         else:
             self.numExamples = numExamplesList[0]
             self.numVariables = numVariablesList[0]
             self.infob.setText("%d variable%s, %d example%s in each file." % (self.numVariables, ["","s"][self.numVariables!=1], self.numExamples, ["","s"][self.numExamples!=1]))
             if self.numExamples > 0:
                 self.infoc.setText('Press Commit button to start ANOVA computation.')
             else:
                 self.infoc.setText('')
             self.boxAnovaType.setEnabled(1)
             self.boxSelection.setEnabled(1)
             self.btnCommit.setEnabled(True)
     else:
         self.infoa.setText('No data on input.')
         self.infob.setText('')
         self.infoc.setText('')
     # enable/disable anova type selection depending on the type of input data
     self.updateAnovaTypeBox()
     self.updateSelectorBox()
     if self.autoUpdateSelName:
         self.updateSelectorName()
     # run ANOVA
     if self.commitOnChange:
         self.runANOVA()
         self.senddata()
     self.updateSelectorInfos()
コード例 #53
0
ファイル: plot.py プロジェクト: ykneisel/topographica
    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
コード例 #54
0
ファイル: colorTool.py プロジェクト: lisarosalina/App
def RedWhiteBlueARamp(size=256):
    ramp = Numeric.ones( (size, 4), 'f')
    mid = size/2
    incr = 1./(mid-1)
    for i in xrange(mid):
        ramp[i][1] = i*incr
        ramp[i][2] = i*incr
    for i in xrange(mid):
        ramp[mid+i][0] = 1.-(i*incr)
        ramp[mid+i][1] = 1.-(i*incr)
    return ramp