def draw_rubberband(self, event, x0, y0, x1, y1):
# Use an Overlay to draw a rubberband-like bounding box.
dc = wx.ClientDC(self.canvas)
odc = wx.DCOverlay(self.wxoverlay, dc)
odc.Clear()
# Mac's DC is already the same as a GCDC, and it causes
# problems with the overlay if we try to use an actual
# wx.GCDC so don't try it.
if 'wxMac' not in wx.PlatformInfo:
dc = wx.GCDC(dc)
height = self.canvas.figure.bbox.height
y1 = height - y1
y0 = height - y0
if y1 < y0: y0, y1 = y1, y0
if x1 < y0: x0, x1 = x1, x0
w = x1 - x0
h = y1 - y0
rect = wx.Rect(x0, y0, w, h)
rubberBandColor = '#C0C0FF' # or load from config?
# Set a pen for the border
color = wx.NamedColour(rubberBandColor)
dc.SetPen(wx.Pen(color, 1))
# use the same color, plus alpha for the brush
r, g, b = color.Get()
color.Set(r, g, b, 0x60)
dc.SetBrush(wx.Brush(color))
dc.DrawRectangleRect(rect)
def _draw_ring_layer(self, dc, data, map_rel):
"""Draw a points layer.
dc the device context to draw on
data an iterable of point tuples:
(x, y, place, radius, colour, x_off, y_off, pdata)
map_rel points relative to map if True, MUST BE TRUE for lightweight
Assumes all points are the same colour, saving 100's of ms.
"""
assert map_rel is True
if len(data) == 0:
return
(lon, lat, place, radius, colour, x_off, y_off, pdata) = data[0]
scale = 2**self._pyslip.tiles.zoom_level
# Draw points on map/view, using transparency if implemented.
try:
dc = wx.GCDC(dc)
except NotImplementedError:
pass
dc.SetPen(wx.Pen(colour))
dc.SetBrush(wx.Brush(colour, wx.TRANSPARENT))
for (lon, lat, place, radius, colour, x_off, y_off, pdata) in data:
(x, y) = self._pyslip.ConvertGeo2View((lon, lat))
dc.DrawCircle(x, y, radius * scale)
def OnPaint(self, event):
sz = self.GetClientSize()
pdc = wx.BufferedPaintDC(self)
try:
dc = wx.GCDC(pdc)
except Exception:
dc = pdc
isModalDialogShown = False
for win in wx.GetTopLevelWindows():
if isinstance(win, wx.Dialog) and win.IsModal():
isModalDialogShown = True
break
dc.SetBrush(wx.BLACK_BRUSH)
dc.DrawRectangle(0, 0, sz[0], sz[1])
if not self.IsEnabled() and not isModalDialogShown:
# a modal dialog set this window to disabled (not enabled), but
# this windows is set to disabled if no selection can
# be made (multiple selected images)
# this rectangle should only be drawn if this windows is set to
# disabled programmatically and not when a modal dialog is shown
dc.SetBrush(
wx.Brush(wx.Colour(90, 90, 90, 255), wx.HORIZONTAL_HATCH))
dc.DrawRectangle(0, 0, sz[0], sz[1])
elif self._imgProxy is not None:
self.__DrawBitmap(dc)
self.__DrawSection(dc)
event.Skip()
def DoPaint(self):
'''Realiza el redibujo usual luego de inicializado el control'''
dc = wx.BufferedPaintDC(self)
ancho, alto = self.GetSize()
dc.SetBackground(wx.BLACK_BRUSH)
dc.Clear()
dc.DrawBitmap(self._bmpDrawCache, 0,0)
x,y=self.formula.GetPosition()
self.ShowColourInSB()
if self._imodo == MODO_FORMULA:
dc.DrawBitmap(self.formula.bitmap,x,y,1) #el uno indica para usar máscara
if self._selection !=None:
if self._selectionBmp !=None:
x,y=self._selection.pos
dc.DrawBitmap(self._selectionBmp,x,y,1)
estilo = wx.PENSTYLE_DOT_DASH
if self._selectionBmp:
estilo = wx.PENSTYLE_SHORT_DASH
normalPen=wx.Pen(self._drawColour, 1, estilo )
dc.SetBrush(wx.TRANSPARENT_BRUSH)
dc.SetPen(normalPen)
self._selection.Draw(dc)
if self._imodo == MODO_DIBUJO:
if self._figure !=None:
pen=wx.Pen(self._drawColour, self._penWidth, wx.PENSTYLE_SOLID )
# Define un DC que permite el suavizado
dc = wx.GCDC(dc)
dc.SetBrush(wx.TRANSPARENT_BRUSH)
dc.SetPen(pen)
self._figure.Draw(dc)
def OnPaint(self, event):
"""Draws the Caption and border around the controls"""
dc = wx.PaintDC(self)
gcdc = wx.GCDC(dc)
gc = gcdc.GetGraphicsContext()
# Get the working rectangle we can draw in
rect = self.GetClientRect()
# Setup the GraphicsContext
gc.SetPen(wx.TRANSPARENT_PEN)
rgb = self._color.Get(False)
alpha = self._color.Alpha() *.2 # fade to transparent
color2 = wx.Colour(*rgb, alpha=alpha)
x1, y1 = rect.x, rect.y
y2 = y1 + rect.height
gradbrush = gc.CreateLinearGradientBrush(x1, y1,
x1, y2,
self._color,
color2)
gc.SetBrush(gradbrush)
# Draw the background
gc.DrawRoundedRectangle(rect.x, rect.y,
rect.width, rect.height,
rect.height/2)
# Use the GCDC to help draw the aa text
gcdc.DrawLabel(self._label, rect, wx.ALIGN_CENTER)
def OnPaint(self, event):
#dc = wx.BufferedPaintDC(self, self.bitmap)
dc = wx.BufferedPaintDC(self, self.buffer, wx.BUFFER_VIRTUAL_AREA)
#dc.DrawBitmap(self.bitmap, 0, 0)
odc = wx.DCOverlay(self.overlay, dc)
odc.Clear()
if self.LeftClickFlag == 1:
dc.SetPen(wx.Pen('red', 1))
dc.DrawLine(self.LeX, 0, self.LeX, 150)
if self.RightClickFlag == 1:
dc.SetPen(wx.Pen('blue', 1))
dc.DrawLine(self.RiX, 0, self.RiX, 150)
#Draw a transparent rectangle to emphasize the selected area
if (self.LeftClickFlag == 1 and self.RightClickFlag == 1
and self.LeX != self.RiX):
Colour = wx.Colour(139, 0, 255, 100) #notice the alpha channel
brush = wx.Brush(Colour)
if self.RiX > self.LeX:
width = self.RiX - self.LeX
x = self.LeX
else:
width = self.LeX - self.RiX
x = self.RiX
height = self.bitmap.GetHeight()
pdc = wx.GCDC(dc)
pdc.SetBrush(brush)
pdc.DrawRectangle(x, 0, width, height)
dc.SetPen(wx.Pen('yellow', 1))
dc.DrawLine(-self.CalcScrolledPosition(0, 0)[0] + 150, 0,
-self.CalcScrolledPosition(0, 0)[0] + 150, 150)
dc.SetPen(wx.Pen('green', 1))
dc.DrawLine(self.CurrPos, 0, self.CurrPos, 150)
del odc
#SKIP THE DRAWING OF RULER WHICH SEVERELY STUCK THE RENDERING
event.Skip()
def _on_paint(self, event):
if not self.palette: return
height = self.GetSize()[1]
pdc = wx.PaintDC(self)
try:
dc = wx.GCDC(self.pdc)
except:
dc = pdc
dc.BeginDrawing()
pdc.BeginDrawing()
w = self.cell_width
h = self.cell_height
y = -1 * self.position * h
for color in self.colors:
if y > -h and y < height:
pdc.SetPen(wx.Pen(wx.Colour(0, 0, 0), 1))
pdc.SetBrush(wx.Brush(wx.Colour(*color)))
pdc.DrawRectangle(0, y, w, h + 1)
y += h
if not pdc == dc:
dc.EndDrawing()
pdc.EndDrawing()
else:
dc.EndDrawing()
pdc = dc = None
def Draw(self, dc):
'''
Method for drawing stuff on self.gcdc.
This method is responsible for drawing the entire user interface, with the exception of buttons. I add those later.
'''
#set up the gcdc
dc.SetBackground(wx.Brush("White"))
dc.Clear() # make sure you clear the bitmap!
self.gcdc = wx.GCDC(dc) #make gcdc from the dc (for use of transparency and antialiasing)
#make a hidden dc to which features can be drawn in unique colors and later used for hittests. This drawing only exists in memory.
self.unique_color = (0,0,0)
self.hidden_dc = wx.MemoryDC()
self.hidden_dc.SelectObject(wx.EmptyBitmap(self.ClientSize[0], self.ClientSize[1]))
self.hidden_dc.SetBackground(wx.Brush("White"))
self.hidden_dc.Clear() # make sure you clear the bitmap!
#draw amino acids in one of two representations
if self.properties_layout is True:
self.Draw_properties()
else:
self.Draw_wheel()
#draw key explaining highlighting colors
self.Draw_key()
#draw degenerate nucleotide
self.Draw_codon()
#draw graph showing fequency of amino acids encoded
self.Draw_graph()
def _on_paint(self, event):
w, h = self.panel.GetSize()
pdc = wx.PaintDC(self.panel)
try:
dc = wx.GCDC(pdc)
except:
dc = pdc
dc.BeginDrawing()
color1 = wx.Colour(0, 0, 0, 10)
color2 = wx.Colour(0, 0, 0, 0)
rect = wx.Rect(0, h / 2, w, h / 2)
dc.GradientFillLinear(rect, color1, color2, nDirection=wx.NORTH)
rect = wx.Rect(0, 0, w, h / 2)
dc.GradientFillLinear(rect, color1, color2, nDirection=wx.SOUTH)
pdc.SetPen(wx.Pen(wx.Colour(*const.UI_COLORS['hover_solid_border']),
1))
pdc.DrawLine(0, h - 1, w, h - 1)
pdc.DrawLine(0, 0, w, 0)
if not pdc == dc:
dc.EndDrawing()
pdc.EndDrawing()
else:
dc.EndDrawing()
pdc = dc = None
def onMapPaint(self, event):
panel = event.GetEventObject()
panel_key = None
for k, v in self.map_panels.iteritems():
if v == panel:
panel_key = k
break
if panel_key not in self.map_bitmaps:
return
pdc = wx.AutoBufferedPaintDC(panel)
try:
dc = wx.GCDC(pdc)
except:
dc = pdc
dc.BeginDrawing()
# Draw background
dc.DrawBitmap(self.map_bitmaps[panel_key], 0, 0)
dc.EndDrawing()
event.Skip()
def paint_matrix(self, context):
try:
dc = wx.GCDC(context)
except NotImplementedError:
dc = context
pen_col = brush_col = self.bg_colour
dc.SetPen(wx.Pen(pen_col, width=1))
dc.SetBrush(wx.Brush(brush_col))
px, py = self.stat_padding
w, h = self.stat_bmp.Size
for column in range(self.columns):
for row in range(self.rows):
point = px + (column * (w + self.spacing)), py + (row * (h + self.spacing))
rect = wx.Rect(point, self.stat_size)
col_val = self.value[column]
# using Deflate to correct for the extra line width added by DrawRectangle
# if col_val >= self.rows - row: # Use this method if only drawing rects (not bmps)
# dc.DrawRectangle(rect.Deflate(self.colour_shrink))
dc.DrawRectangle(rect.Deflate(self.colour_shrink))
dc.DrawBitmap(self.bmp_pair[col_val >= self.rows - row], point)
def drawSubView(self, lisa_idx, bufferWidth, bufferHeight, bmp):
dc = wx.BufferedDC(None, bmp)
dc.SetBrush(wx.WHITE_BRUSH)
dc.SetPen(wx.TRANSPARENT_PEN)
dc.DrawRectangle(0, 0, bufferWidth, bufferHeight)
if not "Linux" in stars.APP_PLATFORM:
# not good drawing effect using GCDC in linux
dc = wx.GCDC(dc)
view = View2ScreenTransform(self.extent, bufferWidth, bufferHeight)
ml = self.moran_locals[lisa_idx]
# 0 not significant, 1 HH, 2 LL, 3 LH, 4 HL, 5 Neighborless
sigFlag = ml[2]
clusterFlag = ml[3]
lm_sig = np.array(sigFlag)
lm_q = np.array(clusterFlag)
id_groups = [[] for i in range(6)]
for i, sig in enumerate(lm_sig):
if sig > 0:
id_groups[lm_q[i]].append(i)
else:
id_groups[0].append(i)
from stars.visualization.maps.BaseMap import PolygonLayer
draw_layer = PolygonLayer(self, self.layer, build_spatial_index=False)
#edge_clr = wx.WHITE#wx.Colour(200,200,200, self.opaque)
edge_clr = self.color_schema_dict[self.layer.name].edge_color
draw_layer.set_edge_color(edge_clr)
draw_layer.set_data_group(id_groups)
draw_layer.set_fill_color_group(self.lisa_color_group)
draw_layer.draw(dc, view)
def OnLeftDClick(self, event):
x, y = event.GetX(), event.GetY()
bDrawDetail = False
year_idx = -1
month_idx = -1
year_idx = self.get_clicked_year(x, y)
if year_idx >= 0:
bDrawDetail = True
self.selected_year = year_idx
else:
month_idx = self.get_clicked_month(x, y)
if month_idx >= 0:
self.selected_month = month_idx
bDrawDetail = True
if bDrawDetail:
tmpBuffer = wx.EmptyBitmapRGBA(self.bufferWidth, self.bufferHeight,
255, 255, 255, 255)
dc = wx.BufferedDC(None, tmpBuffer)
if not 'Linux' in stars.APP_PLATFORM \
and 'Darwin' != stars.APP_PLATFORM:
dc = wx.GCDC(dc)
dc.DrawBitmap(self.buffer, 0, 0)
dc.SetPen(wx.TRANSPARENT_PEN)
dc.SetBrush(wx.Brush(wx.Colour(100, 100, 100, 200)))
dc.DrawRectangle(0, 0, self.bufferWidth, self.bufferHeight)
if year_idx >= 0:
self.draw_year_detail(dc, year_idx)
elif month_idx >= 0:
self.draw_month_detail(dc, month_idx)
self.buffer = tmpBuffer
#dc.Destroy()
self.Refresh(False)
def OnPaint(self, event):
w, h = self.GetClientSizeTuple()
delta = min((w - 2) // COLS, (h - 2) // ROWS)
x_offset = (w - (COLS * delta)) // 2
y_offset = (h - (ROWS * delta)) // 2
dc = wx.BufferedPaintDC(self)
dc.SetBackground(wx.WHITE_BRUSH)
dc.Clear()
dc = wx.GCDC(dc)
full = delta - 4
progress = (np.sqrt(self.progress / self.full_count) *
full).astype(int)
for r in range(ROWS):
y = r * delta + y_offset
for c in range(COLS):
x = c * delta + x_offset
d = progress[r, c]
if (d > 2) and ((delta - d) % 2 == 1):
d -= 1
gap = (delta - d) // 2 + 1
if d == full:
dc.SetBrush(wx.Brush(self.full_color))
else:
dc.SetBrush(wx.Brush(self.color))
dc.SetPen(wx.NullPen)
if d:
dc.DrawRectangle(x + gap, y + gap, d + 1, d + 1)
dc.SetBrush(wx.NullBrush)
dc.SetPen(wx.Pen(wx.BLACK, 0.5))
dc.DrawRectangle(x + 2, y + 2, delta - 1, delta - 1)
def onPaint(self, event=None):
if self.mapBitmap is None:
return
if event is None:
dc = wx.ClientDC(self.window_1_pane_1)
else:
pdc = wx.AutoBufferedPaintDC(self.window_1_pane_1)
try:
dc = wx.GCDC(pdc)
except:
dc = pdc
dc.BeginDrawing()
# Draw background
dc.DrawBitmap(self.mapBitmap, 0, 0)
# Draw robot
if self.robotPos is not None:
[x,y] = map(lambda x: int(self.mapScale*x), self.robotPos)
dc.DrawCircle(x, y, 5)
if self.markerPos is not None:
[m,n] = map(lambda m: int(self.mapScale*m), self.markerPos)
dc.SetBrush(wx.Brush(wx.RED))
dc.DrawCircle(m, n, 5)
# Draw velocity vector of robot (for debugging)
#dc.DrawLine(self.robotPos[0], self.robotPos[1],
# self.robotPos[0] + self.robotVel[0], self.robotPos[1] + self.robotVel[1])
dc.EndDrawing()
if event is not None:
event.Skip()
def addSolution(self, vrp, solution, sheet, nodeInfoList):
# thumbnail creation
memdc = wx.MemoryDC()
bitmap = wx.EmptyBitmap(self.thumbnailWidth, self.thumbnailHeight)
memdc.SelectObject(bitmap)
dc = wx.GCDC(memdc)
canvas = wxcanvas.WxThumbnailCanvas(dc,
self.thumbnailWidth,
self.thumbnailHeight)
sheet.paint(vrp, solution, canvas, thumbnail=True)
memdc.Destroy()
self.GetImageList().Add(bitmap)
# panel creation
panel = VrpPanel(self,
inputData=vrp,
solutionData=solution,
styleSheet=sheet,
nodeInfoList=nodeInfoList)
# newName = reduce(lambda x, y: x+ y,
# [ x if i % 10 != 9 else x + '\n'
# for i, x in enumerate(solution.name) ] )
# print newName
newName = solution.name if len(solution.name) < 15 \
else solution.name[:12] + '...' + solution.name[-3:]
self.AddPage(panel,
newName,
imageId=self.GetPageCount())
def _on_paint(self, event):
w, h = self.panel.GetSize()
pdc = wx.PaintDC(self.panel)
try:
dc = wx.GCDC(pdc)
except:
dc = pdc
dc.BeginDrawing()
dc.SetBrush(wx.Brush(wx.Colour(*wal.UI_COLORS['bg'])))
dc.SetPen(wx.TRANSPARENT_PEN)
dc.DrawRectangle(0, 0, w, h)
color1 = wx.Colour(0, 0, 0, 20)
color2 = wx.Colour(0, 0, 0, 0)
rect = wx.Rect(0, 0, w / 2, h)
dc.GradientFillLinear(rect, color1, color2, nDirection=wx.EAST)
pdc.SetPen(wx.Pen(wx.Colour(*wal.UI_COLORS['hover_solid_border']), 1))
pdc.DrawLine(0, 0, 0, h)
if not pdc == dc:
dc.EndDrawing()
pdc.EndDrawing()
else:
dc.EndDrawing()
def OnPaint(self, evt):
dc = wx.PaintDC(self)
dc = wx.GCDC(dc)
dc.SetBackground(self.bkg_brush)
dc.Clear()
dc.DrawEllipticArc(100, 200, 200, 200 - self.v_pos, 90, 270)
dc.DrawLine(100, 100, 100, 300)
def _on_paint(self, event):
if not self.palette: return
width = self.GetSize()[0]
pdc = wx.PaintDC(self)
try:
dc = wx.GCDC(self.pdc)
except:
dc = pdc
dc.BeginDrawing()
pdc.BeginDrawing()
w = self.cell_width
h = self.cell_height
x = -1 * self.position * w
for color in self.colors:
if x > -w and x < width:
pdc.SetPen(wx.Pen(wx.Colour(0, 0, 0), 1))
pdc.SetBrush(wx.Brush(wx.Colour(*color)))
pdc.DrawRectangle(x, 0, w + 1, h)
x += w
if not pdc == dc:
dc.EndDrawing()
pdc.EndDrawing()
else:
dc.EndDrawing()
pdc = dc = None
def _on_paint(self, _event):
h = self.GetSize()[1]
pdc = wx.PaintDC(self)
dc = wx.GCDC(pdc)
x = 10
y = h - self.bmp_size[1] - 10
dc.DrawBitmap(self.bmp, x, y, True)
def __SwapBuffers(self, canvas):
self.__buffer, self.__temp_buffer = self.__temp_buffer, self.__buffer
self.__dc.SelectObject(self.__buffer)
self.__temp_dc.SelectObject(self.__temp_buffer)
self.__graphics_dc = wx.GCDC(self.__dc)
self.__graphics_dc.SetFont(self.__dc.GetFont())
self.__graphics_dc.SetLogicalScale(canvas.MAX_ZOOM, canvas.MAX_ZOOM)
def get_dc(self):
"""return the client drawing context"""
gc = wx.GCDC(wx.ClientDC(self.image))
ink = wx.Colour(0x99, 0xcc, 0xff, 0x88)
gc.SetPen(wx.Pen(ink))
gc.SetBrush(wx.Brush(ink))
return gc
def __CreateDiaBmp(self,
picIdx,
selected=False,
highlighted=False,
dropIdx=None):
pic = self.__pictures[picIdx]
thumbBmp = ImageCache().GetThumbBmp(pic)
diaRect = self.GetDiaRect(picIdx)
holeOffset = diaRect.x
bmp = wx.Bitmap(diaRect.width, diaRect.height)
diaNo = str(picIdx + 1)
label = os.path.splitext(os.path.basename(pic.GetFilename()))[0]
dc = wx.MemoryDC(bmp)
try:
dc = wx.GCDC(dc)
except Exception:
pass
if dropIdx is not None:
diaNo = str(dropIdx + 1)
dropRect = self.GetDiaRect(dropIdx)
if dropIdx > picIdx:
holeOffset = dropRect.right + 1 - diaRect.width
diaRect.SetX(0)
self.__DrawDia(dc, diaRect, holeOffset, thumbBmp, diaNo, label,
selected, highlighted)
return bmp
def onPaint(self, event=None):
if self.mapBitmap is None:
return
if event is None:
dc = wx.ClientDC(self.panel_1)
else:
pdc = wx.AutoBufferedPaintDC(self.panel_1)
try:
dc = wx.GCDC(pdc)
except:
dc = pdc
else:
self.panel_1.PrepareDC(pdc)
self.panel_1.PrepareDC(dc)
dc.BeginDrawing()
# Draw background
dc.DrawBitmap(self.mapBitmap, 0, 0)
# Draw robot
if self.current_region is not None:
[x,
y] = map(lambda x: int(self.mapScale * x),
self.proj.rfi.regions[self.current_region].getCenter())
dc.DrawCircle(x, y, 5)
dc.EndDrawing()
if event is not None:
event.Skip()
def OnDraw(self, event=None):
dc = wx.PaintDC(self)
gdc = wx.GCDC(dc)
(sx, sy) = self.GetSize()
if (self.firstDraw):
print(f"Panelsize: {sx}x{sy}")
self.firstDraw = False
x0 = 0
y0 = sy / 2
dc.SetPen(wx.Pen(wx.BLACK, style=wx.TRANSPARENT))
dc.DrawRectangle(0, 0, sx, sy)
(bx, by) = self.mapBmp.GetSize()
dc.DrawBitmap(self.mapBmp, (sx - bx) / 2, (sy - by) / 2)
gtx = gdc.GetGraphicsContext()
gtx.BeginLayer(0.6)
gdc.SetPen(wx.Pen(wx.BLUE, 5, style=wx.SHORT_DASH))
DrawAngle(gtx, self.lowerSetpoint, offset=(sx / 2.0, sy / 2.0))
gdc.SetPen(wx.Pen(wx.BLUE, 5, style=wx.SOLID))
DrawAngle(gtx, self.lowerPosition, offset=(sx / 2.0, sy / 2.0))
color = wx.Colour(70, 180, 70)
gdc.SetPen(wx.Pen(color, 5, style=wx.SHORT_DASH))
DrawAngle(gtx, self.upperSetpoint, offset=(sx / 2.0, sy / 2.0))
gdc.SetPen(wx.Pen(color, 5, style=wx.SOLID))
DrawAngle(gtx, self.upperPosition, offset=(sx / 2.0, sy / 2.0))
gtx.EndLayer()
if (self.newSetpoint >= 0):
gdc.SetPen(wx.Pen(wx.RED, 5, style=wx.SOLID))
DrawAngle(gtx, self.newSetpoint, offset=(sx / 2.0, sy / 2.0))
def drawSubGiMap(self, idx, bufferWidth, bufferHeight, bmp):
"""
Draw two relative Gi* maps for current Gi* map
"""
dc = wx.BufferedDC(None, bmp)
dc.SetBrush(wx.WHITE_BRUSH)
dc.SetPen(wx.TRANSPARENT_PEN)
dc.DrawRectangle(0, 0, bufferWidth, bufferHeight)
if not "Linux" in stars.APP_PLATFORM:
# not good drawing effect using GCDC in linux
dc = wx.GCDC(dc)
view = View2ScreenTransform(self.extent, bufferWidth, bufferHeight)
p_values = self.space_gstar[idx]
z_values = self.space_gstar_z[idx]
not_sig = list(np.where(p_values > 0.05)[0])
sig = set(np.where(p_values <= 0.05)[0])
hotspots = list(sig.intersection(set(np.where(z_values >= 0)[0])))
coldspots = list(sig.intersection(set(np.where(z_values < 0)[0])))
id_groups = [not_sig, hotspots, coldspots]
from stars.visualization.maps.BaseMap import PolygonLayer
draw_layer = PolygonLayer(self, self.layer, build_spatial_index=False)
#edge_clr = wx.Colour(200,200,200, self.opaque)
edge_clr = self.color_schema_dict[self.layer.name].edge_color
draw_layer.set_edge_color(edge_clr)
draw_layer.set_data_group(id_groups)
draw_layer.set_fill_color_group(self.gi_color_group)
draw_layer.draw(dc, view)
return bmp
def OnPaint(self, evt):
"""Paint the control"""
dc = wx.AutoBufferedPaintDCFactory(self)
gc = wx.GCDC(dc)
# Setup
dc.SetBrush(wx.TRANSPARENT_BRUSH)
gc.SetBrush(wx.TRANSPARENT_BRUSH)
gc.SetFont(self.GetFont())
gc.SetBackgroundMode(wx.TRANSPARENT)
gc.Clear()
# Paint the background
rect = self.GetClientRect()
self.DoPaintBackground(gc, rect, self._color, self._color2)
# Draw the buttons
# TODO: would be more efficient to just redraw the buttons that
# need redrawing.
npos = SegmentBar.HPAD
if self.IsVerticalMode():
npos = SegmentBar.VPAD
use_labels = self._style & CTRLBAR_STYLE_LABELS
for idx, button in enumerate(self._buttons):
npos = self.DoDrawButton(gc, npos, idx,
self._selected == idx,
use_labels)
def onPaint(self, event=None):
if self.mapBitmap is None:
return
if event is None:
dc = wx.ClientDC(self.panel_map)
else:
pdc = wx.AutoBufferedPaintDC(self.panel_map)
try:
dc = wx.GCDC(pdc)
except:
dc = pdc
dc.BeginDrawing()
# Draw background
dc.DrawBitmap(self.mapBitmap, 0, 0)
# Draw robot
if self.robotPos is not None:
[x, y] = map(lambda x: int(self.mapScale * x), self.robotPos)
dc.DrawCircle(x, y, 15)
dc.EndDrawing()
if event is not None:
event.Skip()
def draw_rect(self, dc, rect=None, id=ImageUtil.ID_NONE, color=wx.RED, style=wx.PENSTYLE_SOLID): # 画矩形透明区域
# dc -> 绘图上下文，必需
# rect -> wx.Rect类型，由外部传入
# id -> int类型，标识图形类别
# color -> 颜色
# style -> 样式
if self.start_pos is None or self.end_pos is None:
return
try:
odc = wx.DCOverlay(self.overlay, dc)
odc.Clear()
if 'wxMac' not in wx.PlatformInfo:
dc = wx.GCDC(dc)
dc.SetPen(wx.Pen(colour=color,
width=self.overlayPenWidth.GetValue(),
style=style))
bc = wx.RED
bc = wx.Colour(bc.red, bc.green, bc.blue, 0x80)
dc.SetBrush(wx.Brush(bc))
if rect is None:
rect = wx.Rect(topLeft=self.start_pos, bottomRight=self.end_pos)
dc.DrawRectangle(rect)
self.objects[id].append(rect)
except Exception as e:
Util.LOG.error(repr(e))
def draw3DMap(self, bmp, idx, bufferWidth, bufferHeight):
dc = wx.BufferedDC(None, bmp)
dc.SetBrush(wx.WHITE_BRUSH)
dc.SetPen(wx.TRANSPARENT_PEN)
dc.DrawRectangle(0, 0, bufferWidth, bufferHeight)
if not "Linux" in stars.APP_PLATFORM:
# not good drawing effect using GCDC in linux
dc = wx.GCDC(dc)
view = View2ScreenTransform(self.extent, bufferWidth, bufferHeight)
view.zoom_extent = self.map_query_region
subBmpHeight = self.bufferHeight / self.t
ratio = bufferHeight / float(subBmpHeight)
from stars.visualization.maps.BaseMap import PolygonLayer
draw_layer = PolygonLayer(self, self.layer, build_spatial_index=False)
p_values = self.space_gstar[idx]
z_values = self.space_gstar_z[idx]
not_sig = list(np.where(p_values > 0.05)[0])
sig = set(np.where(p_values <= 0.05)[0])
hotspots = list(sig.intersection(set(np.where(z_values >= 0)[0])))
coldspots = list(sig.intersection(set(np.where(z_values < 0)[0])))
id_groups = [not_sig, hotspots, coldspots]
self.id_groups = id_groups
draw_layer.set_data_group(id_groups)
draw_layer.set_fill_color_group(self.gi_color_group)
draw_layer.set_edge_color(stars.DEFAULT_MAP_EDGE_COLOR)
edge_clr = wx.Colour(200, 200, 200, self.opaque)
draw_layer.set_edge_color(edge_clr)
draw_layer.draw(dc, view, draw3D=ratio)
