def get_rgba(self, tex, fontsize=10, dpi=80, rgb=(0,0,0)): """ Return tex string as an rgba array """ # dvipng assumes a constant background, whereas we want to # overlay these rasters with antialiasing over arbitrary # backgrounds that may have other figure elements under them. # When you set dvipng -bg Transparent, it actually makes the # alpha channel 1 and does the background compositing and # antialiasing itself and puts the blended data in the rgb # channels. So what we do is extract the alpha information # from the red channel, which is a blend of the default dvipng # background (white) and foreground (black). So the amount of # red (or green or blue for that matter since white and black # blend to a grayscale) is the alpha intensity. Once we # extract the correct alpha information, we assign it to the # alpha channel properly and let the users pick their rgb. In # this way, we can overlay tex strings on arbitrary # backgrounds with antialiasing # # red = alpha*red_foreground + (1-alpha)*red_background # Since the foreground is black (0) and the background is # white (1) this reduces to red = 1-alpha or alpha = 1-red # assuming standard 10pt design size space dpi = fontsize/10.0 * dpi r,g,b = rgb key = tex, dpi, tuple(rgb) Z = self.arrayd.get(key) if Z is None: # force=True to skip cacheing while debugging pngfile = self.make_png(tex, dpi, force=False) X = readpng(pngfile) vers = self.get_dvipng_version() #print 'dvipng version', vers if vers<'1.6': # hack the alpha channel as described in comment above alpha = sqrt(1-X[:,:,0]) else: # dvipng 1.6 and above handles the alpha channel # properly [JDH: for some reason I had square root in # here which isn't correct #alpha = sqrt(X[:,:,-1]) alpha = X[:,:,-1] Z = zeros(X.shape, Float) Z[:,:,0] = r Z[:,:,1] = g Z[:,:,2] = b Z[:,:,3] = alpha self.arrayd[key] = Z return Z
def get_rgba(self, tex, fontsize=None, dpi=None, rgb=(0, 0, 0)): """ Return tex string as an rgba array """ # dvipng assumes a constant background, whereas we want to # overlay these rasters with antialiasing over arbitrary # backgrounds that may have other figure elements under them. # When you set dvipng -bg Transparent, it actually makes the # alpha channel 1 and does the background compositing and # antialiasing itself and puts the blended data in the rgb # channels. So what we do is extract the alpha information # from the red channel, which is a blend of the default dvipng # background (white) and foreground (black). So the amount of # red (or green or blue for that matter since white and black # blend to a grayscale) is the alpha intensity. Once we # extract the correct alpha information, we assign it to the # alpha channel properly and let the users pick their rgb. In # this way, we can overlay tex strings on arbitrary # backgrounds with antialiasing # # red = alpha*red_foreground + (1-alpha)*red_background # # Since the foreground is black (0) and the background is # white (1) this reduces to red = 1-alpha or alpha = 1-red if not fontsize: fontsize = rcParams['font.size'] if not dpi: dpi = rcParams['savefig.dpi'] r, g, b = rgb key = tex, fontsize, dpi, tuple(rgb) Z = self.arrayd.get(key) if Z is None: # force=True to skip cacheing while debugging pngfile = self.make_png(tex, fontsize, dpi, force=False) X = readpng(os.path.join(self.texcache, pngfile)) if (self.dvipngVersion < '1.6') or rcParams['text.dvipnghack']: # hack the alpha channel as described in comment above alpha = sqrt(1 - X[:, :, 0]) else: alpha = X[:, :, -1] Z = zeros(X.shape, Float) Z[:, :, 0] = r Z[:, :, 1] = g Z[:, :, 2] = b Z[:, :, 3] = alpha self.arrayd[key] = Z return Z
def get_rgba(self, tex, fontsize=None, dpi=None, rgb=(0,0,0)): """ Return tex string as an rgba array """ # dvipng assumes a constant background, whereas we want to # overlay these rasters with antialiasing over arbitrary # backgrounds that may have other figure elements under them. # When you set dvipng -bg Transparent, it actually makes the # alpha channel 1 and does the background compositing and # antialiasing itself and puts the blended data in the rgb # channels. So what we do is extract the alpha information # from the red channel, which is a blend of the default dvipng # background (white) and foreground (black). So the amount of # red (or green or blue for that matter since white and black # blend to a grayscale) is the alpha intensity. Once we # extract the correct alpha information, we assign it to the # alpha channel properly and let the users pick their rgb. In # this way, we can overlay tex strings on arbitrary # backgrounds with antialiasing # # red = alpha*red_foreground + (1-alpha)*red_background # # Since the foreground is black (0) and the background is # white (1) this reduces to red = 1-alpha or alpha = 1-red if not fontsize: fontsize = rcParams['font.size'] if not dpi: dpi = rcParams['savefig.dpi'] r,g,b = rgb key = tex, fontsize, dpi, tuple(rgb) Z = self.arrayd.get(key) if Z is None: # force=True to skip cacheing while debugging pngfile = self.make_png(tex, fontsize, dpi, force=False) X = readpng(os.path.join(self.texcache, pngfile)) if (self.dvipngVersion < '1.6') or rcParams['text.dvipnghack']: # hack the alpha channel as described in comment above alpha = sqrt(1-X[:,:,0]) else: alpha = X[:,:,-1] Z = zeros(X.shape, Float) Z[:,:,0] = r Z[:,:,1] = g Z[:,:,2] = b Z[:,:,3] = alpha self.arrayd[key] = Z return Z
def get_grey(self, tex, fontsize=None, dpi=None): key = tex, self.get_font_config(), fontsize, dpi alpha = self.grey_arrayd.get(key) if alpha is None: pngfile = self.make_png(tex, fontsize, dpi) X = readpng(os.path.join(self.texcache, pngfile)) if (self.dvipngVersion < '1.6') or rcParams['text.dvipnghack']: # hack the alpha channel as described in comment above alpha = npy.sqrt(1-X[:,:,0]) else: alpha = X[:,:,-1] self.grey_arrayd[key] = alpha return alpha
def get_grey(self, tex, fontsize=None, dpi=None): key = tex, self.get_font_config(), fontsize, dpi alpha = self.grey_arrayd.get(key) if alpha is None: pngfile = self.make_png(tex, fontsize, dpi) X = readpng(os.path.join(self.texcache, pngfile)) if (self.dvipngVersion < '1.6') or rcParams['text.dvipnghack']: # hack the alpha channel as described in comment above alpha = npy.sqrt(1 - X[:, :, 0]) else: alpha = X[:, :, -1] self.grey_arrayd[key] = alpha return alpha
def get_grey(self, tex, fontsize=None, dpi=None): key = tex, self.get_font_config(), fontsize, dpi alpha = self.grey_arrayd.get(key) if alpha is None: pngfile = self.make_png(tex, fontsize, dpi) X = readpng(os.path.join(self.texcache, pngfile)) if rcParams['text.dvipnghack'] is not None: hack = rcParams['text.dvipnghack'] else: hack = self._dvipng_hack_alpha if hack: # hack the alpha channel # dvipng assumed a constant background, whereas we want to # overlay these rasters with antialiasing over arbitrary # backgrounds that may have other figure elements under them. # When you set dvipng -bg Transparent, it actually makes the # alpha channel 1 and does the background compositing and # antialiasing itself and puts the blended data in the rgb # channels. So what we do is extract the alpha information # from the red channel, which is a blend of the default dvipng # background (white) and foreground (black). So the amount of # red (or green or blue for that matter since white and black # blend to a grayscale) is the alpha intensity. Once we # extract the correct alpha information, we assign it to the # alpha channel properly and let the users pick their rgb. In # this way, we can overlay tex strings on arbitrary # backgrounds with antialiasing # # red = alpha*red_foreground + (1-alpha)*red_background # # Since the foreground is black (0) and the background is # white (1) this reduces to red = 1-alpha or alpha = 1-red #alpha = npy.sqrt(1-X[:,:,0]) # should this be sqrt here? alpha = 1 - X[:, :, 0] else: alpha = X[:, :, -1] self.grey_arrayd[key] = alpha return alpha
def get_grey(self, tex, fontsize=None, dpi=None): key = tex, self.get_font_config(), fontsize, dpi alpha = self.grey_arrayd.get(key) if alpha is None: pngfile = self.make_png(tex, fontsize, dpi) X = readpng(os.path.join(self.texcache, pngfile)) if rcParams['text.dvipnghack'] is not None: hack = rcParams['text.dvipnghack'] else: hack = self._dvipng_hack_alpha if hack: # hack the alpha channel # dvipng assumed a constant background, whereas we want to # overlay these rasters with antialiasing over arbitrary # backgrounds that may have other figure elements under them. # When you set dvipng -bg Transparent, it actually makes the # alpha channel 1 and does the background compositing and # antialiasing itself and puts the blended data in the rgb # channels. So what we do is extract the alpha information # from the red channel, which is a blend of the default dvipng # background (white) and foreground (black). So the amount of # red (or green or blue for that matter since white and black # blend to a grayscale) is the alpha intensity. Once we # extract the correct alpha information, we assign it to the # alpha channel properly and let the users pick their rgb. In # this way, we can overlay tex strings on arbitrary # backgrounds with antialiasing # # red = alpha*red_foreground + (1-alpha)*red_background # # Since the foreground is black (0) and the background is # white (1) this reduces to red = 1-alpha or alpha = 1-red #alpha = npy.sqrt(1-X[:,:,0]) # should this be sqrt here? alpha = 1-X[:,:,0] else: alpha = X[:,:,-1] self.grey_arrayd[key] = alpha return alpha