Beispiel #1
0
    def drawsurf1(self,steplist=None):
	'drawsurf1(self,steplist=None) - draw spectrum surface cell by stepwise'
	self.clearcanvas()
	self.createAxis()
	# use color table if ctable is set
	if self.ctable:
	    p = reshape(self.CT[self.ct],(256,3))
	    spec=[]
	    for i in range(256):
		pp = p[i]
		st = '#%02x%02x%02x' % (int(pp[0]),int(pp[1]),int(pp[2]))
		spec.append(st)	
	    self.ctc = spec
	da = self.data
	dv = self.vmax-self.vmin
	if dv != 0.:
		data = divide(subtract(da,self.vmin),dv/self.maxY)
		da1 = divide(subtract(da,self.vmin),dv/255)
	else:
		data = da
		da1 = divide(da,self.vmin/255)

	rows= len(data)
	steps= len(data[0])
	lasthv = self.maxY*self.yfac
        xadj   = float(self.xincr)/4.0
	if xadj < 2: xadj=2	
	if steplist == None:
		steplist = range(steps-1)
#	for cidx in range(steps-1):
	for cidx in steplist:
	    for row in range(rows-1):
                rootx  = self.xorg + cidx*self.xincr - row*self.hoff/self.rows
                rooty  = self.yorg + row*self.voff/self.rows
		datum = [data[rows-1-row][cidx+1],data[rows-1-row][cidx],data[rows-1-row-1][cidx],data[rows-1-row-1][cidx+1]]
	        lside = multiply(datum,self.yfac)
		if self.ctable:
		     if not(self.average):
			ind = int(da1[rows-1-row,cidx])
		     else:
			ind = int((da1[rows-1-row,cidx]+da1[rows-1-row-1,cidx]+ da1[rows-1-row,cidx+1]+da1[rows-1-row-1,cidx+1])/4)
		     color = self.ctc[ind]
		else:
		     color = self.spectrum[cidx]
		self.canvas.create_polygon(
			rootx+self.xincr,rooty-lside[0],
			rootx,rooty-lside[1],
			rootx-self.hroff,rooty-lside[2]+self.vroff,
			rootx+self.xincr-self.hroff,rooty-lside[3]+self.vroff,
                        fill=color, outline=color,
                        width=xadj)

	    self.root.update()
Beispiel #2
0
    def drawrows(self,list=None):
	'drawrows(self,list=None) - draw all or list of rows in 3D coordinates'
	self.clearcanvas()
	self.createAxis()
	da = self.data
	dv = self.vmax-self.vmin
	if dv != 0.0:
		data = divide(subtract(da,self.vmin),dv/self.maxY)
	else:
		data = da
	rows= len(data)
	steps= len(data[0])
	lasthv = self.maxY*self.yfac
	
	if list == None: list = range(rows)
	for row in list:
	  if row < rows and row >=0 :
#            rootx  = self.xorg - row*self.hoff/self.rows
#            rooty  = self.yorg + row*self.voff/self.rows
#	     rowdata1 = data[rows-1-row]
            rootx  = self.xorg - (rows-1-row)*self.hoff/self.rows
            rooty  = self.yorg + (rows-1-row)*self.voff/self.rows
	    rowdata1 = data[row]
	    for cidx in range(steps-1):
		datum = [rowdata1[cidx],rowdata1[cidx+1]]
		lside = multiply(datum,self.yfac)
		self.canvas.create_line( rootx,rooty-lside[0],
			rootx+self.xincr,rooty-lside[1],
			capstyle=ROUND,
			width=self.linewidth,fill='darkblue')
		rootx = rootx + self.xincr

	    self.root.update()
Beispiel #3
0
    def drawsurf(self,type=None):
	'drawsurf(self,type=None) - draw spectrum surface with/without skirt'
	da = self.data
	dv = self.vmax-self.vmin
	if dv != 0.:
		data = divide(subtract(da,self.vmin),dv/self.maxY)
	else:
		data = da
	rows= len(data)
	steps= len(data[0])
	lasthv = self.maxY*self.yfac
	
	for row in range(rows):
            rootx  = self.xorg - row*self.hoff/self.rows
            rooty  = self.yorg + row*self.voff/self.rows
	    rowdata = data[rows-1-row]
	    for cidx in range(steps):
		datum = rowdata[cidx]
		lside = datum*self.yfac
		color = self.spectrum[cidx]
		if type == None:
                    self.canvas.create_polygon(rootx, rooty-lside, 
                        fill=color, outline=color,
                        width=self.xincr)
		else:
                    self.canvas.create_polygon(rootx, rooty-lside, 
			rootx+self.hroff, rooty-lside-self.vroff,
			rootx+self.hroff, rooty-self.vroff,
			rootx,rooty-lside,
                        fill=color, outline=color,
                        width=self.xincr)
		rootx = rootx + self.xincr
	    self.root.update()
Beispiel #4
0
 def applyTransform(self, distance, elevation, azimuth, position):
     """This applies the camera's modelview matrix transform.
        Note that position is now the position the camera orbits around,
        and elevation specifies how far the camera is above the XY plane,
        in degrees.
        """
     glLoadIdentity()
     glTranslatef(0, 0, -distance)
     glRotatef(elevation - 90, 1.0, 0.0, 0.0)
     glRotatef(-(azimuth + self.azimuthOffset), 0.0, 0.0, 1.0)
     glTranslatef(*subtract((0,0,0), position))
Beispiel #5
0
    def draw(self):
	'draw(self) - draw 3D spectrum plot and 2D image plot of input data array'
	da = self.data
	dv = self.vmax-self.vmin
        for i in range(self.rows):
	    if dv == 0: 
	       data = self.steps* [1.]
	    else:
	       data = divide(subtract(da[self.maxY-1-i],self.vmin),dv/self.maxY)
            self.plotData(i, data)
            self.root.update()
	self.drawImage()
Beispiel #6
0
 def draw(self):
     'draw(self) - draw 3D spectrum plot and 2D image plot of input data array'
     da = self.data
     dv = self.vmax - self.vmin
     for i in range(self.rows):
         if dv == 0:
             data = self.steps * [1.]
         else:
             data = divide(subtract(da[self.maxY - 1 - i], self.vmin),
                           dv / self.maxY)
         self.plotData(i, data)
         self.root.update()
     self.drawImage()
Beispiel #7
0
    def drawstepSline(self, list=None):
        'drawstepSline(self,list=None) - draw selected step slices in spectrum color'
        self.clearcanvas()
        self.createAxis()
        da = self.data
        dv = self.vmax - self.vmin
        if dv != 0.0:
            data = divide(subtract(da, self.vmin), dv / self.maxY)
        else:
            data = da
        rows = len(data)
        steps = len(data[0])
        lasthv = self.maxY * self.yfac

        if list == None: list = range(steps)
        else:
            ll = []
            for i in range(len(list)):
                if list[i] < steps:
                    ll.append(list[i])
            list = ll
        np = len(list)
        for row in range(rows - 1):
            rootx = self.xorg - row * self.hoff / self.rows
            rooty = self.yorg + row * self.voff / self.rows
            rowdata1 = data[rows - 1 - row]
            rowdata2 = data[rows - 1 - row - 1]
            for i in range(np):
                cidx = list[i]
                if cidx >= 0 and cidx < steps:
                    datum = [rowdata2[cidx], rowdata1[cidx]]
                    lside = multiply(datum, self.yfac)
                    color = self.spectrum[cidx]
                    self.canvas.create_polygon(rootx - self.hroff,
                                               rooty - lside[0] + self.vroff,
                                               rootx,
                                               rooty - lside[1],
                                               rootx,
                                               rooty,
                                               rootx - self.hroff,
                                               rooty + self.vroff,
                                               outline=color,
                                               width=self.linewidth,
                                               fill=color)
                    if np < steps:
                        if i < (np - 1):
                            rootx = rootx + self.xincr * (list[i + 1] - cidx)
                    else:
                        rootx = rootx + self.xincr

            self.root.update()
Beispiel #8
0
    def render(self):
        GLOrtho.setup()

        # Set the square inside our viewport by one
        # pixel so the antialiased lines won't be chopped in half.
        GLOrtho.translate(1,1)
        size = subtract(self.viewport.size, (2,2))

        # Translucent filling
        GLOrtho.setColor(0,0,0,0.3)
        GLOrtho.filledRect(size)

        # Bright border
        GLOrtho.setColor(1,1,1,1)
        GLOrtho.rectOutline(size)
Beispiel #9
0
    def drawstepSline(self,list=None):
	'drawstepSline(self,list=None) - draw selected step slices in spectrum color'
	self.clearcanvas()
	self.createAxis()
	da = self.data
	dv = self.vmax-self.vmin
	if dv != 0.0:
		data = divide(subtract(da,self.vmin),dv/self.maxY)
	else:
		data = da
	rows= len(data)
	steps= len(data[0])
	lasthv = self.maxY*self.yfac
	
	if list == None: list=range(steps)
	else:
		ll = []
		for i in range(len(list)):
			if list[i] < steps:
				ll.append(list[i])	
		list = ll
    	np = len(list)
	for row in range(rows-1):
            rootx  = self.xorg - row*self.hoff/self.rows
            rooty  = self.yorg + row*self.voff/self.rows
	    rowdata1 = data[rows-1-row]
	    rowdata2 = data[rows-1-row-1]
	    for i in range(np):
	      cidx = list[i]
	      if cidx >=0 and cidx < steps:
		datum = [rowdata2[cidx],rowdata1[cidx]]
		lside = multiply(datum,self.yfac)
		color = self.spectrum[cidx]
		self.canvas.create_polygon(
			rootx-self.hroff,rooty-lside[0]+self.vroff,
			rootx,rooty-lside[1],
			rootx,rooty,
			rootx-self.hroff,rooty+self.vroff,
			outline=color,width=self.linewidth,
			fill=color)
		if np < steps:
		    if i < (np-1):
		        rootx = rootx + self.xincr*(list[i+1]-cidx)
		else:
		    rootx = rootx + self.xincr

	    self.root.update()
Beispiel #10
0
    def drawsteps(self, list=None):
        'drawsteps(self,list=None) - draw all or selected step list in 3D coordinates'
        self.clearcanvas()
        self.createAxis()
        da = self.data
        dv = self.vmax - self.vmin
        if dv != 0.0:
            data = divide(subtract(da, self.vmin), dv / self.maxY)
        else:
            data = da
        rows = len(data)
        steps = len(data[0])
        lasthv = self.maxY * self.yfac

        if list == None: list = range(steps)
        else:
            ll = []
            for i in range(len(list)):
                if list[i] < steps:
                    ll.append(list[i])
            list = ll
        np = len(list)
        for row in range(rows - 1):
            rootx = self.xorg - row * self.hoff / self.rows
            rooty = self.yorg + row * self.voff / self.rows
            rowdata1 = data[rows - 1 - row]
            rowdata2 = data[rows - 1 - row - 1]
            for i in range(np):
                cidx = list[i]
                if cidx >= 0 and cidx < steps:
                    datum = [rowdata1[cidx], rowdata2[cidx]]
                    lside = multiply(datum, self.yfac)
                    self.canvas.create_line(
                        rootx,
                        rooty - lside[0],
                        rootx - self.hroff,
                        rooty - lside[1] + self.vroff,
                        #			capstyle=ROUND,
                        width=self.linewidth,
                        fill='darkblue')
                    if np < steps:
                        if i < (np - 1):
                            rootx = rootx + self.xincr * (list[i + 1] - cidx)
                    else:
                        rootx = rootx + self.xincr

            self.root.update()
Beispiel #11
0
    def drawsteps(self,list=None):
	'drawsteps(self,list=None) - draw all or selected step list in 3D coordinates'
	self.clearcanvas()
	self.createAxis()
	da = self.data
	dv = self.vmax-self.vmin
	if dv != 0.0:
		data = divide(subtract(da,self.vmin),dv/self.maxY)
	else:
		data = da
	rows= len(data)
	steps= len(data[0])
	lasthv = self.maxY*self.yfac
	
	if list == None: list=range(steps)
	else:
		ll = []
		for i in range(len(list)):
			if list[i] < steps:
				ll.append(list[i])	
		list = ll
    	np = len(list)
	for row in range(rows-1):
            rootx  = self.xorg - row*self.hoff/self.rows
            rooty  = self.yorg + row*self.voff/self.rows
	    rowdata1 = data[rows-1-row]
	    rowdata2 = data[rows-1-row-1]
	    for i in range(np):
	      cidx = list[i]
	      if cidx >=0 and cidx < steps:
		datum = [rowdata1[cidx],rowdata2[cidx]]
		lside = multiply(datum,self.yfac)
		self.canvas.create_line(
			rootx,rooty-lside[0],
			rootx-self.hroff,rooty-lside[1]+self.vroff,
#			capstyle=ROUND,
			width=self.linewidth,fill='darkblue')
		if np < steps:
		    if i < (np-1):
		        rootx = rootx + self.xincr*(list[i+1]-cidx)
		else:
		    rootx = rootx + self.xincr

	    self.root.update()
Beispiel #12
0
    def drawmesh(self):
        'drawmesh(self) - draw surface elements as mesh elements'
        self.clearcanvas()
        self.createAxis()
        da = self.data
        dv = self.vmax - self.vmin
        if dv != 0.:
            data = divide(subtract(da, self.vmin), dv / self.maxY)
        else:
            data = da
        rows = len(data)
        steps = len(data[0])
        lasthv = self.maxY * self.yfac

        for row in range(rows - 1):
            rootx = self.xorg - row * self.hoff / self.rows
            rooty = self.yorg + row * self.voff / self.rows
            rowdata1 = data[rows - 1 - row]
            rowdata2 = data[rows - 1 - row - 1]
            for cidx in range(steps - 1):
                datum = [
                    rowdata2[cidx], rowdata1[cidx], rowdata1[cidx + 1],
                    rowdata2[cidx + 1]
                ]
                lside = multiply(datum, self.yfac)
                self.canvas.create_line(rootx - self.hroff,
                                        rooty - lside[0] + self.vroff,
                                        rootx,
                                        rooty - lside[1],
                                        rootx + self.xincr,
                                        rooty - lside[2],
                                        rootx + self.xincr - self.hroff,
                                        rooty - lside[3] + self.vroff,
                                        fill='darkblue')
                if (row + 1) == (rows - 1):
                    self.canvas.create_line(rootx + self.xincr - self.hroff,
                                            rooty - lside[3] + self.vroff,
                                            rootx - self.hroff,
                                            rooty - lside[0] + self.vroff,
                                            fill='darkblue')
                rootx = rootx + self.xincr

            self.root.update()
Beispiel #13
0
    def drawsurf(self, type=None):
        'drawsurf(self,type=None) - draw spectrum surface with/without skirt'
        da = self.data
        dv = self.vmax - self.vmin
        if dv != 0.:
            data = divide(subtract(da, self.vmin), dv / self.maxY)
        else:
            data = da
        rows = len(data)
        steps = len(data[0])
        lasthv = self.maxY * self.yfac

        for row in range(rows):
            rootx = self.xorg - row * self.hoff / self.rows
            rooty = self.yorg + row * self.voff / self.rows
            rowdata = data[rows - 1 - row]
            for cidx in range(steps):
                datum = rowdata[cidx]
                lside = datum * self.yfac
                color = self.spectrum[cidx]
                if type == None:
                    self.canvas.create_polygon(rootx,
                                               rooty - lside,
                                               fill=color,
                                               outline=color,
                                               width=self.xincr)
                else:
                    self.canvas.create_polygon(rootx,
                                               rooty - lside,
                                               rootx + self.hroff,
                                               rooty - lside - self.vroff,
                                               rootx + self.hroff,
                                               rooty - self.vroff,
                                               rootx,
                                               rooty - lside,
                                               fill=color,
                                               outline=color,
                                               width=self.xincr)
                rootx = rootx + self.xincr
            self.root.update()
Beispiel #14
0
    def drawmesh(self):
	'drawmesh(self) - draw surface elements as mesh elements'
	self.clearcanvas()
	self.createAxis()
	da = self.data
	dv = self.vmax-self.vmin
	if dv != 0.:
	    data = divide(subtract(da,self.vmin),dv/self.maxY)
	else:
	    data = da
	rows= len(data)
	steps= len(data[0])
	lasthv = self.maxY*self.yfac
	
	for row in range(rows-1):
            rootx  = self.xorg - row*self.hoff/self.rows
            rooty  = self.yorg + row*self.voff/self.rows
	    rowdata1 = data[rows-1-row]
	    rowdata2 = data[rows-1-row-1]
	    for cidx in range(steps-1):
		datum = [rowdata2[cidx],rowdata1[cidx],rowdata1[cidx+1],rowdata2[cidx+1]]
		lside = multiply(datum,self.yfac)
		self.canvas.create_line(
			rootx-self.hroff,rooty-lside[0]+self.vroff,
			rootx,rooty-lside[1],
			rootx+self.xincr,rooty-lside[2],
			rootx+self.xincr-self.hroff,rooty-lside[3]+self.vroff,
			fill='darkblue')
		if (row+1) == (rows-1):
			self.canvas.create_line(
			rootx+self.xincr-self.hroff,rooty-lside[3]+self.vroff,
			rootx-self.hroff,rooty-lside[0]+self.vroff,
			fill='darkblue')
		rootx = rootx + self.xincr

	    self.root.update()
Beispiel #15
0
    def drawrows(self, list=None):
        'drawrows(self,list=None) - draw all or list of rows in 3D coordinates'
        self.clearcanvas()
        self.createAxis()
        da = self.data
        dv = self.vmax - self.vmin
        if dv != 0.0:
            data = divide(subtract(da, self.vmin), dv / self.maxY)
        else:
            data = da
        rows = len(data)
        steps = len(data[0])
        lasthv = self.maxY * self.yfac

        if list == None: list = range(rows)
        for row in list:
            if row < rows and row >= 0:
                #            rootx  = self.xorg - row*self.hoff/self.rows
                #            rooty  = self.yorg + row*self.voff/self.rows
                #	     rowdata1 = data[rows-1-row]
                rootx = self.xorg - (rows - 1 - row) * self.hoff / self.rows
                rooty = self.yorg + (rows - 1 - row) * self.voff / self.rows
                rowdata1 = data[row]
                for cidx in range(steps - 1):
                    datum = [rowdata1[cidx], rowdata1[cidx + 1]]
                    lside = multiply(datum, self.yfac)
                    self.canvas.create_line(rootx,
                                            rooty - lside[0],
                                            rootx + self.xincr,
                                            rooty - lside[1],
                                            capstyle=ROUND,
                                            width=self.linewidth,
                                            fill='darkblue')
                    rootx = rootx + self.xincr

                self.root.update()
Beispiel #16
0
    def drawsurf1(self, steplist=None):
        'drawsurf1(self,steplist=None) - draw spectrum surface cell by stepwise'
        self.clearcanvas()
        self.createAxis()
        # use color table if ctable is set
        if self.ctable:
            p = reshape(self.CT[self.ct], (256, 3))
            spec = []
            for i in range(256):
                pp = p[i]
                st = '#%02x%02x%02x' % (int(pp[0]), int(pp[1]), int(pp[2]))
                spec.append(st)
            self.ctc = spec
        da = self.data
        dv = self.vmax - self.vmin
        if dv != 0.:
            data = divide(subtract(da, self.vmin), dv / self.maxY)
            da1 = divide(subtract(da, self.vmin), dv / 255)
        else:
            data = da
            da1 = divide(da, self.vmin / 255)

        rows = len(data)
        steps = len(data[0])
        lasthv = self.maxY * self.yfac
        xadj = float(self.xincr) / 4.0
        if xadj < 2: xadj = 2
        if steplist == None:
            steplist = range(steps - 1)
#	for cidx in range(steps-1):
        for cidx in steplist:
            for row in range(rows - 1):
                rootx = self.xorg + cidx * self.xincr - row * self.hoff / self.rows
                rooty = self.yorg + row * self.voff / self.rows
                datum = [
                    data[rows - 1 - row][cidx + 1], data[rows - 1 - row][cidx],
                    data[rows - 1 - row - 1][cidx],
                    data[rows - 1 - row - 1][cidx + 1]
                ]
                lside = multiply(datum, self.yfac)
                if self.ctable:
                    if not (self.average):
                        ind = int(da1[rows - 1 - row, cidx])
                    else:
                        ind = int((da1[rows - 1 - row, cidx] +
                                   da1[rows - 1 - row - 1, cidx] +
                                   da1[rows - 1 - row, cidx + 1] +
                                   da1[rows - 1 - row - 1, cidx + 1]) / 4)
                    color = self.ctc[ind]
                else:
                    color = self.spectrum[cidx]
                self.canvas.create_polygon(rootx + self.xincr,
                                           rooty - lside[0],
                                           rootx,
                                           rooty - lside[1],
                                           rootx - self.hroff,
                                           rooty - lside[2] + self.vroff,
                                           rootx + self.xincr - self.hroff,
                                           rooty - lside[3] + self.vroff,
                                           fill=color,
                                           outline=color,
                                           width=xadj)

            self.root.update()