Changeset 1134


Ignore:
Timestamp:
21.01.2016 10:06:26 (4 years ago)
Author:
klaus
Message:

fixed problems with zoom box by switching to XOR drawing of zoombox and prelim phases; XOR colors problematic, use white now

File:
1 edited

Legend:

Unmodified
Added
Removed
  • SHX/trunk/SeismicHandler/modules/wx_.py

    r1133 r1134  
    6666        self.timewindow = (None,None) 
    6767        self.last_number_of_traces = 0 
     68        self._xor_line = None 
     69        self._xor_rect = None 
    6870 
    6971        # temporary layer for mouse motion 
     
    149151                return (phase.name,phaselist.picktypeName(phase.picktype)) 
    150152        return None 
     153     
     154    def _drawXor( self, mode, coo=(None,None,None,None) ): 
     155        """Draws line (len(coo)==2) or rectangle (len(coo) == 4) in XOR mode. 
     156        Deletes previous line/rectangle. To only clear old element, pass 
     157        None-tuples. 
     158        """ 
     159        if mode == 'clear': 
     160            self._xor_line = None 
     161            self._xor_rect = None 
     162            return 
     163        color = 'white' 
     164        # Line or rectangle? 
     165        islinemode = (mode == 'line') 
     166        # Setup dc. 
     167        size = 2 
     168        dc = wx.ClientDC(self) 
     169        dc.SetLogicalFunction( wx.XOR ) 
     170        dc.SetPen( wx.Pen(color,size,wx.SOLID) ) 
     171        if islinemode: 
     172            if self._xor_line != None: 
     173                # Clear old rectangle. 
     174                dc.DrawLine( *self._xor_line ) 
     175            if coo[0] == None: 
     176                self._xor_line = None 
     177            else: 
     178                # Draw new rectangle. 
     179                dc.DrawLine( *coo ) 
     180                self._xor_line = coo 
     181        else: 
     182            if self._xor_rect != None: 
     183                # Clear old rectangle. 
     184                dc.DrawRectangle( *self._xor_rect ) 
     185            if coo[0] == None: 
     186                self._xor_rect = None 
     187            else: 
     188                # Draw new rectangle. 
     189                dc.DrawRectangle( *coo ) 
     190                self._xor_rect = coo 
    151191 
    152192    # event processing 
     
    239279        dragwidth = None 
    240280        if evt.Dragging() and trace: 
    241             # new overlay for live display 
    242             dc = wx.ClientDC(self) 
    243             odc = wx.DCOverlay(self.overlay_drag, dc) 
    244             odc.Clear() 
    245             dc.SetBrush(wx.TRANSPARENT_BRUSH) 
    246  
    247281            th2 = self.traceheight / 2 
    248282            shx_graphics = trace.get_graphics() 
     
    259293                    plotter.setZoomWindow( None, None, None ) 
    260294                if self.zoomwdwwidth == 0.: 
    261                     self.__zoombox( dc, self.dragStart, (x, y), 
     295                    self.__zoombox( self.dragStart, (x, y), 
    262296                        shx_graphics.midpoint, size=2 ) 
    263297                    dragwidth = x - self.dragStart[0] 
     
    265299                    _start = [x-self.zoomwdwwidth/2,y] 
    266300                    _end = [x+self.zoomwdwwidth/2,y] 
    267                     self.__zoombox( dc, _start, _end, 
     301                    self.__zoombox( _start, _end, 
    268302                        shx_graphics.midpoint, size=2 ) 
    269303                    dragwidth = _end[0] - _start[0] 
    270304            # draw position line 
    271305            elif evt.LeftIsDown(): 
    272                 dc.SetPen(wx.Pen("Blue", 1)) 
    273306                if self.traceOrder in [0, 1]: 
    274                     dc.DrawLine( 
     307                    self._drawXor( 'line', ( 
    275308                        x, mmth2 - self.Scrolled, 
    276309                        x, mpth2 - self.Scrolled 
    277                     ) 
     310                    ) ) 
    278311                elif self.traceOrder in [2, 3]: 
    279                     dc.DrawLine( 
     312                    self._drawXor( 'line', ( 
    280313                        mmth2 - self.Scrolled, y, 
    281314                        mpth2 - self.Scrolled, y 
    282                     ) 
    283             del odc 
     315                    ) ) 
    284316 
    285317        stext = "%s - %s - %s" % (fromUTCDateTime(timestamp), reltimestr, tid) 
     
    749781                end = self.TraceAndTimeToScreen(trace, end) 
    750782                self._debug("draw zoom window") 
    751                 self.__zoombox(dc, start, end, shx_graphics.midpoint, 
     783                self.__zoombox( start, end, shx_graphics.midpoint, 
    752784                    color="Blue") 
    753785            else: 
     
    756788                if plotter: 
    757789                    plotter.setZoomWindow( None, None, None ) 
     790                self.__zoombox( None, None, None ) 
    758791 
    759792 
     
    782815        time scale. 
    783816        """ 
    784         # we cannot use the Screen module because of loop imports 
     817        # Get dimensions of the drawing area and number of traces to plot. 
     818        # We cannot use the Screen module because of loop imports. 
    785819        if self._timewindow[1] is None: 
    786820            timewindow = get_runtime("extend") 
    787821        else: 
    788822            timewindow = self._timewindow 
    789         width, height = self.GetVirtualSize() 
     823        self.width, self.height = self.GetVirtualSize() 
    790824        numTraces = len(self.traces) - Overlays.numberOfOverlays() 
    791         # delete zoom window if number of traces has changed 
     825        globalnorm = self._normtype.startswith("A") 
     826 
     827        # Delete zoom window if number of traces has changed. 
     828        # -> i.e. not drawn in this redraw. 
    792829        if self.last_number_of_traces != numTraces and self.ZoomWindow: 
    793830            self.ZoomWindow = None 
     
    795832                plotter.setZoomWindow( None, None, None ) 
    796833        self.last_number_of_traces = numTraces 
    797         globalnorm = self._normtype.startswith("A") 
    798  
    799         # compute trace height (theight) as float, otherwise trace positioning 
     834        self._drawXor( 'clear' ) 
     835 
     836        # How much space is left for each trace: 
     837        #    theight: height of trace space in pixel units 
     838        #    pltwidth: width of trace space in pixel units 
     839        # Compute trace height (theight) as float, otherwise trace positioning 
    800840        # is weird when many traces on screen. 
    801841        if self.traceOrder in [0, 1]: 
    802842            if numTraces: 
    803                 theight = float(height - TIMESCALE - MARGINS[0] \ 
     843                theight = float(self.height - TIMESCALE - MARGINS[0] \ 
    804844                    - MARGINS[2]) / numTraces 
    805845            else: 
    806                 theight = float(height - TIMESCALE) 
    807             pltwidth = width - STATION_INFO - MARGINS[1] - MARGINS[3] 
     846                theight = float(self.height - TIMESCALE) 
     847            pltwidth = self.width - STATION_INFO - MARGINS[1] - MARGINS[3] 
    808848        elif self.traceOrder in [2, 3]: 
    809849            if numTraces: 
    810                 theight = (width - TIMESCALE - MARGINS[1] - MARGINS[3]) / numTraces 
    811             theight = width - TIMESCALE 
    812             pltwidth = height - STATION_INFO - MARGINS[0] - MARGINS[2] 
     850                theight = (self.width - TIMESCALE - MARGINS[1] \ 
     851                    - MARGINS[3]) / numTraces 
     852            theight = self.width - TIMESCALE 
     853            pltwidth = self.height - STATION_INFO - MARGINS[0] - MARGINS[2] 
    813854        else: 
    814855            raise ValueError("unknown trace order %d" % self.traceorder) 
    815856         
    816         self.width = width 
    817         self.height = height 
     857        # Trace height used in scaling routines, 
     858        #   make it visible to other methods. 
    818859        self.traceheight = theight 
    819860 
    820         # bitmap holding the final figure, canvas->DC drawing to this bitmap 
    821         self._bitmap = wx.EmptyBitmap(width, height) 
     861        # Bitmap holding the final figure, canvas->DC drawing to this bitmap. 
     862        self._bitmap = wx.EmptyBitmap(self.width, self.height) 
    822863        canvas = wx.MemoryDC(self._bitmap) 
    823864        canvas.SetBrush(wx.TRANSPARENT_BRUSH) 
     
    825866        canvas.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL)) 
    826867 
     868        # If nothing to display, clear eand exit. 
    827869        if numTraces == 0: 
    828870            # just clearing the screen 
     
    836878            trcs = self.traces 
    837879         
    838         # should traces overlap or stay within their y-ranges 
     880        # Should traces overlap or stay within their y-ranges? 
     881        # Overlapping traces: create taller bitmaps than computed before 
     882        # in theight (zoomed up by a zoom factor). When the trace-bitmaps 
     883        # are copied to the screen buffer, they overlap each other. 
    839884        overlapping_traces = get_runtime( "overlapping_traces", True ) 
    840885 
    841         # init overlays positions 
     886        # Init overlays positions. Overlays change the trace counting, since 
     887        # we need less trace positions. 
    842888        Overlays.initPlot( len(self.traces), self.traceOrder ) 
    843889 
    844         # plot every trace 
     890        # Loop over traces. 
    845891        for i, t in enumerate(trcs): 
    846892            if getattr(t, "shx_graphics", None) is None: 
    847                 # trace not yet established 
     893                # Trace not yet established. 
    848894                continue 
    849895            if not self.relativeAxis: 
     
    861907            # zoomed by a factor if overlapping_traces is selected. 
    862908            if overlapping_traces: 
    863                 # increased zheight produces overlapping of traces on display 
     909                # Increased zheight produces overlapping of traces on display. 
    864910                zheight = int( theight * tzoom ) 
    865911                try: 
     
    871917                prepzoom = 0.9  # why not 1.? 
    872918             
    873             # limit zheight to screen height 
     919            # Limit zheight to screen height, otherwise we run into memory 
     920            # problems. 
    874921            if zheight > self.height: 
    875922                zheight = self.height 
    876923 
     924            # Amplitude scaling factor within bitmap. 
    877925            norm = globalnorm and self.maxAmplitude or self._normtype[1] 
    878             # zoom=1/tzoom makes trace stay within bitmap 
    879             #t.prepare_image_data( pltwidth, zheight, 
    880             #    timewindow, zoom=prepzoom, norm=norm) 
    881                          
     926             
     927            # After eliminating t.prepare_image_data (too slow), this 
     928            # shx_graphics-stuff is probably not needed any more. 
    882929            shx_graphics = t.get_graphics() 
    883930            if shx_graphics == None: 
    884931                continue 
    885932 
    886             # make trace graphics sketch 
     933            # Create an emtpy bitmap for this trace, but only if the pixel 
     934            # height is larger than 4. Doesn't make sense to put time and 
     935            # CPU into figures with only 2 pixels height. Draw simple line 
     936            # instead. 
    887937            if zheight > 4: 
    888938                if self.traceOrder in [0, 1]: 
     
    892942            else: 
    893943                bitmap = None 
    894  
    895944            if bitmap is not None: 
    896945                # buffer to draw in 
     
    903952                dbuffer = None 
    904953 
     954            # Time position of trace. 
    905955            _shift = t.get_info("t-origin") - timewindow[0] 
    906956            if _shift < 0.: 
    907957                _shift = 0. 
    908             # on positive shifts the bitmap is moved out of the screen 
     958            # On positive shifts the bitmap is moved out of the screen 
    909959            # to the right. On negative shifts the bitmap is recomputed 
    910960            # and always starts at 0. Fails if the bitmap move completely 
     
    919969                plotoffset = portion * pltwidth 
    920970 
    921             # get color, etc. attribute 
     971            # Get drawing attributes, color and other styles. 
    922972            attrib = t.get_info("attrib") 
    923973            try: 
     
    943993                color = map( int, [255*x for x in color] ) 
    944994            linestyle = getattr(wx, style.linestyle.upper()) 
     995 
     996            # Draw seismogram into trace bitmap. 
    945997            if dbuffer is not None: 
    946998                dbuffer.SetPen(wx.Pen(color, style.linewidth, linestyle)) 
    947999                dbuffer.BeginDrawing() 
    948                 #dbuffer.DrawLineList(ImageData) 
    9491000                dbuffer.DrawLines( 
    9501001                    self.prepImage(t,pltwidth,zheight,timewindow,prepzoom,norm) 
     
    9521003                dbuffer.EndDrawing() 
    9531004 
    954             # copy trace picture to canvas 
     1005            # Copy trace bitmap to canvas 
    9551006            if dbuffer is not None: 
    9561007                if self.traceOrder in [0, 1]: 
     
    9771028                                                pltwidth, dbuffer, 0, 0, wx.AND) 
    9781029 
    979             # trace numbering 
     1030            # Put labels on traces. 
     1031            # Trace numbering 
    9801032            if self.traceOrder in [1, 2, 3]: 
    9811033                idx = i + 1 
    9821034            elif self.traceOrder == 0: 
    9831035                idx = -i + len(self.traces) 
     1036            # Currently no choice on type of label, just station and component. 
    9841037            txt = "%d: %s %s" % (idx, t.stats.station, t.stats.channel[-1]) 
    985  
    9861038            canvas.SetPen(wx.Pen('Grey', 1, wx.LONG_DASH)) 
    987  
    988             # place trace names 
    989             # helper lines for debugging 
     1039            # Draw labels and helper lines (zero lines) 
    9901040            w, h, _, _ = canvas.GetFullTextExtent(txt) 
    9911041            shx_graphics.midpoint = tmp = i * theight + theight//2 + MARGINS[0] 
    9921042            if self.traceOrder in [0, 1]: 
    9931043                canvas.DrawText(txt, 5 + MARGINS[3], tmp - h // 2) 
    994                 canvas.DrawLine(STATION_INFO + MARGINS[3], tmp, width - MARGINS[1], tmp) 
    995 #                canvas.SetPen(wx.Pen('Red', 1, wx.LONG_DASH)) 
    996 #                canvas.DrawLine(STATION_INFO, tmp + zheight // 2, 
    997 #                                            width - MARGIN, tmp + zheight // 2) 
    998 #                canvas.DrawLine(STATION_INFO, tmp - zheight // 2, 
    999 #                                            width - MARGIN, tmp - zheight // 2) 
     1044                canvas.DrawLine(STATION_INFO + MARGINS[3], tmp, 
     1045                    self.width - MARGINS[1], tmp) 
    10001046            elif self.traceOrder == 2: 
    1001                 canvas.DrawRotatedText(txt, tmp - h // 2, height - MARGIN, 90) 
     1047                canvas.DrawRotatedText(txt, tmp - h // 2, self.height - MARGIN, 90) 
    10021048                canvas.DrawLine(shx_graphics.midpoint, MARGIN, 
    1003                                                     tmp, height - STATION_INFO) 
    1004 #                canvas.SetPen(wx.Pen('Red', 1, wx.LONG_DASH)) 
    1005 #                canvas.DrawLine(tmp + zheight // 2, MARGIN, 
    1006 #                                     tmp + zheight // 2, height - STATION_INFO) 
    1007 #                canvas.DrawLine(tmp - zheight // 2, MARGIN, 
    1008 #                                     tmp - zheight // 2, height - STATION_INFO) 
     1049                    tmp, self.height - STATION_INFO) 
    10091050            elif self.traceOrder == 3: 
    10101051                canvas.DrawRotatedText(txt, tmp - h // 2, 
    10111052                                    STATION_INFO - (STATION_INFO - w) // 2, 90) 
    1012                 canvas.DrawLine(tmp, STATION_INFO, tmp, height - MARGIN) 
    1013 #                canvas.SetPen(wx.Pen('Red', 1, wx.LONG_DASH)) 
    1014 #                canvas.DrawLine(tmp+zheight // 2, STATION_INFO, 
    1015 #                                           tmp + zheight // 2, height - MARGIN) 
    1016 #                canvas.DrawLine(tmp - zheight // 2, STATION_INFO, 
    1017 #                                           tmp - zheight // 2, height - MARGIN) 
    1018  
    1019  
    1020         # time axis 
     1053                canvas.DrawLine(tmp, STATION_INFO, tmp, self.height - MARGIN) 
     1054 
     1055            # End of trace loop 
     1056 
     1057        # Draw time axis. 
    10211058        canvas.SetPen(wx.Pen('Black', 1)) 
    10221059        if self.relativeAxis: 
     
    10251062        if self.traceOrder in [0, 1]: 
    10261063            PARTS = 5.  # axis split into X parts 
    1027             length = width - MARGINS[1] - MARGINS[3] - STATION_INFO  # pixel length of time axis 
    1028             fixpos = height - TIMESCALE - MARGINS[2]  # here: y coordinate 
     1064            length = self.width - MARGINS[1] - MARGINS[3] - STATION_INFO  # pixel length of time axis 
     1065            fixpos = self.height - TIMESCALE - MARGINS[2]  # here: y coordinate 
    10291066            varpos_start = STATION_INFO + MARGINS[3] # here: x start 
    10301067        elif self.traceOrder in [2, 3]: 
    10311068            PARTS = 4. 
    1032             length = height - MARGIN - STATION_INFO 
    1033             fixpos = width - TIMESCALE + 10  # here: x coordinate 
     1069            length = self.height - MARGIN - STATION_INFO 
     1070            fixpos = self.width - TIMESCALE + 10  # here: x coordinate 
    10341071            if self.traceOrder == 2: 
    10351072                varpos_start = MARGIN  # here: y start 
     
    12591296     
    12601297    #@timeit 
    1261     def __zoombox(self, dc, start, end, midpoint, color="DARKORANGE", size=1): 
     1298    def __zoombox(self, start, end, midpoint, color="DARKORANGE", size=1): 
     1299        if start == None: 
     1300            self._drawXor( 'rect', (None,None,None,None) ) 
     1301            return 
    12621302        marginfactor = 0.3 
    12631303        mf2 = (1 - marginfactor) * 2 
    12641304        th2 = self.traceheight / 2 
    12651305        offset = midpoint - th2 - self.Scrolled 
    1266  
    1267         dc.SetPen(wx.Pen(color, size)) 
    12681306        if self.traceOrder in [0, 1]: 
    1269             dc.DrawRectangle(start[0], offset + th2 * marginfactor, 
    1270                                                   end[0] - start[0], th2 * mf2) 
     1307            self._drawXor( 'rect', (start[0], offset + th2 * marginfactor, 
     1308                end[0] - start[0], th2 * mf2) ) 
    12711309        elif self.traceOrder in [2, 3]: 
    1272             dc.DrawRectangle(offset + th2 * marginfactor, start[1], 
    1273                                                   th2 * mf2, end[1] - start[1]) 
     1310            self._drawXor( 'rect', (offset + th2 * marginfactor, start[1], 
     1311                th2 * mf2, end[1] - start[1]) ) 
    12741312 
    12751313 
Note: See TracChangeset for help on using the changeset viewer.