Source Code for Module topo.patterns.rds

  1  """ 
  2  Random-dot stereogram patterns. 
  3   
  4  $Id: rds.py 7861 2008-02-07 06:01:22Z ceball $ 
  5  """ 
  6  __version__='$Revision: 7861 $' 
  7   
  8  from numpy.oldnumeric import zeros,ones,floor,where,choose,less,greater,Int 
  9  from numpy.oldnumeric.random_array import random,seed 
 10   
 11  from topo.base.parameterclasses import Number,Integer 
 12  from topo.base.patterngenerator import PatternGenerator 
 13  from topo.base.parameterizedobject import ParamOverrides 
 14  from topo.base.sheetcoords import SheetCoordinateSystem 
 15  from topo.base.functionfamilies import IdentityOF 
 16   
 17   
 18  ### JABHACKALERT: This code seems to work fine when the input regions 
 19  ### are all the same size and shape, but for 
 20  ### e.g. examples/hierarchical.ty the resulting images in the Test 
 21  ### Pattern preview window are square (instead of the actual 
 22  ### rectangular shapes), matching between the eyes (instead of the 
 23  ### actual two different rectangles), and with dot sizes that don't 
 24  ### match between the eyes.  It's not clear why this happens. 
 25   
 26 -class RandomDotStereogram(PatternGenerator): 
 27      """ 
 28      Random dot stereogram using rectangular black and white patches. 
 29   
 30      Based on Matlab code originally from Jenny Read, implemented in 
 31      Topographica by Tikesh Ramtohul (2006). 
 32      """ 
 33   
 34      # Suppress unused parameters 
 35      x = Number(precedence=-1) 
 36      y = Number(precedence=-1) 
 37      size = Number(precedence=-1) 
 38      orientation = Number(precedence=-1) 
 39   
 40      # Override defaults to make them appropriate 
 41      scale  = Number(default=0.5) 
 42      offset = Number(default=0.5) 
 43   
 44      # New parameters for this pattern 
 45   
 46      #JABALERT: Should rename xdisparity and ydisparity to x and y, and simply 
 47      #set them to different values for each pattern to get disparity 
 48      xdisparity = Number(default=0.0,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), 
 49                          precedence=0.50,doc="Disparity in the horizontal direction.") 
 50       
 51      ydisparity = Number(default=0.0,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), 
 52                          precedence=0.51,doc="Disparity in the vertical direction.") 
 53       
 54      dotdensity = Number(default=0.5,bounds=(0.0,None),softbounds=(0.1,0.9), 
 55                          precedence=0.52,doc="Number of dots per unit area; 0.5=50% coverage.") 
 56   
 57      dotsize    = Number(default=0.1,bounds=(0.0,None),softbounds=(0.05,0.15), 
 58                          precedence=0.53,doc="Edge length of each square dot.") 
 59   
 60      random_seed=Integer(default=500,bounds=(0,1000), 
 61                          precedence=0.54,doc="Seed value for the random position of the dots.") 
 62   
 63   
 64 -    def __call__(self,**params_to_override): 
 65   
 66          # Gather parameters 
 67          self._check_params(params_to_override) 
 68          params = ParamOverrides(self,params_to_override) 
 69           
 70          bounds      = params['bounds'] 
 71          xdensity    = params['xdensity'] 
 72          ydensity    = params['ydensity'] 
 73          scale       = params['scale'] 
 74          offset      = params['offset'] 
 75          output_fn   = params['output_fn'] 
 76          dotdensity  = params['dotdensity'] 
 77          random_seed = params['random_seed'] 
 78   
 79          xsize,ysize = SheetCoordinateSystem(bounds,xdensity,ydensity).shape 
 80          xsize,ysize = int(round(xsize)),int(round(ysize)) 
 81           
 82          xdisparity  = int(round(xsize*params['xdisparity']))   
 83          ydisparity  = int(round(xsize*params['ydisparity']))    
 84          dotsize     = int(round(xsize*params['dotsize'])) 
 85           
 86          bigxsize = 2*xsize 
 87          bigysize = 2*ysize 
 88          ndots=int(round(dotdensity * (bigxsize+2*dotsize) * (bigysize+2*dotsize) / 
 89                          min(dotsize,xsize) / min(dotsize,ysize))) 
 90          halfdot = floor(dotsize/2) 
 91       
 92          # Choose random colors and locations of square dots 
 93          seed(random_seed*12,random_seed*99) 
 94          col=where(random((ndots))>=0.5, 1.0, -1.0) 
 95   
 96          seed(random_seed*122,random_seed*799) 
 97          xpos=floor(random((ndots))*(bigxsize+2*dotsize)) - halfdot 
 98       
 99          seed(random_seed*1243,random_seed*9349) 
100          ypos=floor(random((ndots))*(bigysize+2*dotsize)) - halfdot 
101         
102          # Construct arrays of points specifying the boundaries of each 
103          # dot, cropping them by the big image size (0,0) to (bigxsize,bigysize) 
104          x1=xpos.astype(Int) ; x1=choose(less(x1,0),(x1,0)) 
105          y1=ypos.astype(Int) ; y1=choose(less(y1,0),(y1,0)) 
106          x2=(xpos+(dotsize-1)).astype(Int) ; x2=choose(greater(x2,bigxsize),(x2,bigxsize)) 
107          y2=(ypos+(dotsize-1)).astype(Int) ; y2=choose(greater(y2,bigysize),(y2,bigysize)) 
108   
109          # Draw each dot in the big image, on a blank background 
110          bigimage = zeros((bigysize,bigxsize)) 
111          for i in range(ndots): 
112              bigimage[y1[i]:y2[i]+1,x1[i]:x2[i]+1] = col[i] 
113               
114          result = offset + scale*bigimage[ (ysize/2)+ydisparity:(3*ysize/2)+ydisparity , 
115                                            (xsize/2)+xdisparity:(3*xsize/2)+xdisparity ] 
116   
117          if output_fn is not IdentityOF: 
118              output_fn(result) 
119   
120          return result 
121