Python WordCloud.recolor方法代码示例

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def create_wc(words_in):
    """Create WordCloud object.

    Parameters
    ----------
    words_in : list of tuple
        Words to plot, with their corresponding frequencies.

    Returns
    -------
    wc : WordCloud() object
        Wordcloud definition.
    """

    # Create the WordCloud object
    wc = WordCloud(background_color=None,
                   mode='RGBA',
                   width=800,
                   height=400,
                   prefer_horizontal=1,
                   relative_scaling=0.5,
                   min_font_size=25,
                   max_font_size=80).generate_from_frequencies(words_in)

    # Change colour scheme to grey
    wc.recolor(color_func=_grey_color_func, random_state=3)

    return wc

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def wordCloud(text_array,name,keyword=""):
	new_text_arr=[]
	if keyword is not "":
		keyword=keyword.split(" ")[1]
	for text in text_array:
		if keyword in text:
			new_text_arr.append(text)

	text_array=new_text_arr

	cloud_text=""
	for text in text_array:
		cloud_text+=text+" "

	m_stopwords=['police','traffic','sir']

	for word in m_stopwords:
		STOPWORDS.add(word)

	image_mask = os.path.join(BASE_DIR, 'static/tool/img/nebula.png')
	coloring = imread(image_mask)
	
	wordcloud = WordCloud(stopwords=STOPWORDS,background_color="white",mask=coloring,ranks_only=True,max_words=50).generate(cloud_text)
	filename=os.path.join(BASE_DIR, 'static/tool/img/'+name+'.png')

	image_colors = ImageColorGenerator(coloring)
	wordcloud.recolor(color_func=image_colors)
	wordcloud.to_file(filename)
	data_uri = open(filename, 'rb').read().encode('base64').replace('\n', '')

	img_tag = '<img src="data:image/png;base64,{0}" style="height:400px;">'.format(data_uri)
	
	layout=wordcloud.layout_
	words_colours={}
	count=1
	for lo in layout:
		entry={}
		entry['word']=lo[0][0]
		color=lo[len(lo)-1]
		color=color[4:]
		color=color[:-1]
		color_split=color.split(',')
		color_num=[int(x) for x in color_split]
		color_hex='#%02x%02x%02x' % tuple(color_num)
		# print color_num
		entry['color']=color_hex
		words_colours[count]=entry
		count+=1

	# print words_colours
	list_html=""
	cap=51
	if cap>len(words_colours):
		cap=len(words_colours)

	for i in range(1,cap):
		list_html+='<li class="list-group-item" ><a class="cloud-key-'+name+'" href="#" style="color:'+words_colours[i]['color']+'">'
		list_html+="#"+str(i)+" "+words_colours[i]['word']+'</a></li>'

	return (img_tag,list_html)

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
    def get_tagcloud(self, tags, tag_limit=None):
        tag_limit = tag_limit or len(tags)
        tags = sorted(tags, key=lambda kv: -kv['count'])[:tag_limit]  # Get top X tags
        tag_dict = {t['tag_name']: t['count'] for t in tags}

        # Generate a word cloud image
        wordcloud = WordCloud(
            background_color='white',
            min_font_size=10,
            max_font_size=60,
            width=self.tagcloud_width,
            height=self.tagcloud_height or 30 * len(tags) / 2 + 10,
            font_path=os.path.sep.join([settings.STATIC_ROOT, 'fonts', 'OpenSans-Regular.ttf'])
        ).generate_from_frequencies(tag_dict)

        tag_counts = [t['count'] for t in tags]
        step = (float(max(tag_counts))) / len(self.color_selection)
        thresholds = list(reversed([int(round(i * step)) for i in range(len(self.color_selection))]))

        def get_color(word, font_size, position, orientation, random_state=None, **kwargs):
            index = next((i for i, t in enumerate(thresholds) if tag_dict[word] >= t), 0)
            return self.color_selection[index]

        wordcloud.recolor(color_func=get_color)
        image = wordcloud.to_image()
        filepath = self.get_write_to_path(ext="png")
        image.save(filepath)
        return encode_file_to_base64(filepath, "data:image/png;base64,")

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def make_word_cloud(product, sentiment):
    if sentiment == "all":
        pos, neg = get_top_five_phrases(product,sentiment)

        pos.index = range(0,len(pos))
        neg.index = range(0,len(neg))

        pos_words_array = []
        neg_words_array = []
        for i in range(0,len(pos)):
            pos_words_array.append((pos["vocab"][i].upper(), float(pos["count"][i])))

        for i in range(0,len(neg)):
            neg_words_array.append((neg["vocab"][i].upper(), float(neg["count"][i])))

        wc = WordCloud(background_color="white", max_words=2000,
               max_font_size=300, random_state=42)

        # generate word cloud for positive
        positive_name = '../app/static/img/pos_wordcloud.png'
        wc.generate_from_frequencies(pos_words_array)
        wc.recolor(color_func=pos_color_func, random_state=3)
        wc.to_file(positive_name)

        # generate word cloud for negative
        negative_name = '../app/static/img/neg_wordcloud.png'
        wc.generate_from_frequencies(neg_words_array)
        wc.recolor(color_func=neg_color_func, random_state=3)
        wc.to_file(negative_name)

        return positive_name, negative_name

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def test_recolor_too_small():
    # check exception is raised when image is too small
    colouring = np.array(Image.new('RGB', size=(20, 20)))
    wc = WordCloud(width=30, height=30, random_state=0, min_font_size=1).generate(THIS)
    image_colors = ImageColorGenerator(colouring)
    with pytest.raises(ValueError, match='ImageColorGenerator is smaller than the canvas'):
        wc.recolor(color_func=image_colors)

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def word_cloud(csv_file, stopwords_path, pic_path):
    pic_name = csv_file+"_词云图.png"
    path = os.path.abspath(os.curdir)
    csv_file = path+ "\\" + csv_file + ".csv"
    csv_file = csv_file.replace('\\', '\\\\')
    d = pd.read_csv(csv_file, engine='python', encoding='utf-8')
    content = []
    for i in d['content']:
        try:
            i = translate(i)
        except AttributeError as e:
            continue
        else:
            content.append(i)
    comment_after_split = jieba.cut(str(content), cut_all=False)
    wl_space_split = " ".join(comment_after_split)
    backgroud_Image = plt.imread(pic_path)
    stopwords = STOPWORDS.copy()
    with open(stopwords_path, 'r', encoding='utf-8') as f:
        for i in f.readlines():
            stopwords.add(i.strip('\n'))
        f.close()

    wc = WordCloud(width=1024, height=768, background_color='white',
                   mask=backgroud_Image, font_path="C:\simhei.ttf",
                   stopwords=stopwords, max_font_size=400,
                   random_state=50)
    wc.generate_from_text(wl_space_split)
    img_colors = ImageColorGenerator(backgroud_Image)
    wc.recolor(color_func=img_colors)
    plt.imshow(wc)
    plt.axis('off')  
    plt.show() 
    wc.to_file(pic_name)

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def generateWordCloud(node, contribs, maskImg=None, wordsToShow=100, normalize=True, normMin=0, normMax=1):
    contrib = contribs[node]
    
    # Find side of largest magnitude
    # take k words from that side
    # normalize those words (may need abs val)
    # generate text from those normalized values
    
    # contrib should be sorted high to low
    maxVal = abs(contrib[0][1])
    minVal = abs(contrib[-1][1])
    
    #print (contrib[0][1], contrib[-1][1])
    #print ("max min = ", maxVal, minVal)
    
    newContrib = []
    if (maxVal > minVal): 
        # use front
        
        #newContrib = contrib[0:min(len(contrib), wordsToShow))]
        
        for i in range(min(len(contrib), wordsToShow)):
            newContrib.append(contrib[i])
    else:
        # use back
        for i in range(min(len(contrib), wordsToShow) - 1, -1, -1):
            newContrib.append(contrib[i])
        
        # if the most significant value was negative
        # swap the sign of all values in contrib
        for j in range(len(newContrib)):
            c = newContrib[j]
            newContrib[j] = (c[0], -1*c[1])
    
    #print ("new contrib = ", newContrib)
    
    if (normalize):
        contrib = normalizeContrib(newContrib, normMin, normMax)
    
    # for each value in normalized contrib
    # assign color value
    for c in contrib:
        word, val = c
        # add word to color map
        #wordColorMap[word] = int(round(255*(1-val)))
        wordColorMap[word] = int(round(200*(1-val)))
        
    
    # generate text
    text = generateText(contrib, min(len(contrib), wordsToShow))
    
    # gen word cloud
    #s = time.time()
    wc = WordCloud(background_color="white", max_words=2000, mask=maskImg)
    wc.generate(text)
    wc.recolor(color_func=gray_color_func)
    #e = time.time()
    #print ("word cloud only time = ", (e-s))
    return wc    

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def wd_cloud(request):
    base_path = path.dirname(__file__)
    font_path = path.join(base_path, 'static/fonts/simsun.ttc')
    text = [list_.list_name for list_ in SongList.objects.all()]
    # join函数的作用是将列表中的多个字符串拼接成一个长字符串
    text = ','.join(text)
    # 关于jieba的更多使用方法，可以参考原作者的github
    topK = 160
    tags = jieba.analyse.extract_tags(text, topK=topK, withWeight=True)
    text = ','.join([tag[0] for tag in tags])
    queryword = request.GET.get('queryword')
    # 使用objects.filter方法所得到的是一个QuerySet，而使用objects.get方法得到的是一个对象
    # 因此此处使用的是filter方法,此外，如果需要选择不满足条件的集合，就使用exclude方法
    res = SongList.objects.filter(list_name__contains=queryword)

    # 判断是否有歌曲重复出现在某几个歌单中
    links = ['http://music.163.com/api/playlist/detail?id=' + str(r.list_id) for r in res]
    id_lists = list()
    name_dict = dict()
    json_texts = [json.loads(requests.get(link).text) for link in links]
    # songs_appear_manytimes is a list of tuples with each tuple containing
    #  a song list's id, time it appears and its name
    songs_appear_manytimes = list()
    for i in range(len(json_texts)):
        t = json_texts[i]['result']['tracks']
        for j in range(len(t)):
            song_id = t[j]['id']
            song_name = t[j]['name']
            id_lists.append(song_id)
            name_dict[song_id] = song_name
    d = collections.Counter(id_lists)
    for k in d:
        if d[k] > 1:
            songs_appear_manytimes.append((name_dict[k], d[k], k))
            print(k)
            print(d[k])
            print(name_dict[k])

    json_response = dict()
    json_response['lists_contain_queryword'] = [(r.list_name, r.list_link) for r in res]
    json_response['songs_appaer_manytimes'] = songs_appear_manytimes
    pprint(json_response)
    region = (32, 107, 992, 661)
    mask = np.array(Image.open(path.join(base_path, "static/images/nike-logo.jpg")).crop(region).rotate(90))
    mulan_style = np.array(Image.open(path.join(base_path, "static/images/a.png")).rotate(90))
    color_style = ImageColorGenerator(mulan_style)
    wordcloud = WordCloud(font_path=font_path, mask=mask, background_color='white', max_words=400, width=400,
                          height=800, max_font_size=50, min_font_size=20, relative_scaling=.9, scale=2.0).generate(text)
    wordcloud.recolor(color_func=color_style)
    cloud_img_path = path.join(base_path, "static/images/cloud.png")
    wordcloud.to_file(cloud_img_path)

    return JsonResponse(json_response)

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def test_check_errors():
    wc = WordCloud()
    assert_raises(NotImplementedError, wc.to_html)

    try:
        np.array(wc)
        raise AssertionError("np.array(wc) didn'm raise")
    except ValueError as e:
        assert_true("call generate" in str(e))

    try:
        wc.recolor()
        raise AssertionError("wc.recolor didn'm raise")
    except ValueError as e:
        assert_true("call generate" in str(e))

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def run_dm():
    dm = ds.acquire_dailymotion()
    dmimg = imread("dmlogo.png")
    # Read the whole text.
    wc = WordCloud(mask=dmimg)
    image_colors = ImageColorGenerator(dmimg)
    wc.generate(word_list_dailymotion(ds.mean(dm[0]), ds.standard_deviation(dm[0])))
    
    
    # Open a plot of the generated image.
    plt.imshow(wc.recolor(color_func=image_colors))
    plt.axis("off")
    plt.savefig('popularWordsDM.png', bbox_inches = 'tight', dpi = 200)
    words, vidcount = ds.word_count_dailymotion(ds.mean(dm[0]), ds.standard_deviation(dm[0]))
    data1 = []
    data2 = []
    labels = []
    count = 0
    for w in sorted(words, key=words.get, reverse=True):   
        labels.append(w)
        data1.append(1000 * words[w]/vidcount)
        count +=1
        if count == 10:
            break
    words, vidcount = ds.word_count_dailymotion( 0, 0 )
    for w in labels:
        data2.append(1000 * words[w]/vidcount)
    create_dualbargraph(data1, data2, labels, 'wordUseCompDM.png')
    create_bargraph(da.dm_thetas(),('fans','duration','date created', 'y-intercept'), 'barGraphDM.png')

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def create_wordcloud(corpus, output, stopword_dict):
    lex_dic = build_lex_dic(corpus, stopword_dict=stopword_dict)
    total_words = get_total_words(lex_dic)
    ordered_freq_list = build_freq_list(lex_dic, total_words)

    fig = plt.figure(figsize=(10, 8), frameon=False)
    ax = plt.Axes(fig, [0., 0., 1., 1.])
    ax.set_axis_off()
    fig.add_axes(ax)
    wordcloud = WordCloud(width=1000, height=800, max_words=100, background_color='white',
                          relative_scaling=0.7, random_state=15, prefer_horizontal=0.5).generate_from_frequencies(
        ordered_freq_list[0:100])
    wordcloud.recolor(random_state=42, color_func=my_color_func)

    ax.imshow(wordcloud)
    fig.savefig(output, facecolor='white')

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def test_check_errors():
    wc = WordCloud()
    with pytest.raises(NotImplementedError):
        wc.to_html()

    try:
        np.array(wc)
        raise AssertionError("np.array(wc) didn't raise")
    except ValueError as e:
        assert "call generate" in str(e)

    try:
        wc.recolor()
        raise AssertionError("wc.recolor didn't raise")
    except ValueError as e:
        assert "call generate" in str(e)

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def make_wordle_from_mallet(word_weights_file, 
                            num_topics, 
                            words,
                            TopicRanksFile,
                            outfolder,
                            font_path, 
                            dpi):
    """
    # Generate wordles from Mallet output, using the wordcloud module.
    """
    print("\nLaunched make_wordle_from_mallet.")
    for topic in range(0,num_topics):
        ## Gets the text for one topic.
        text = get_wordlewords(words, word_weights_file, topic)
        wordcloud = WordCloud(font_path=font_path, width=1600, height=1200, background_color="white", margin=4).generate(text)
        default_colors = wordcloud.to_array()
        rank = get_topicRank(topic, TopicRanksFile)
        figure_title = "topic "+ str(topic) + " ("+str(rank)+"/"+str(num_topics)+")"       
        plt.imshow(wordcloud.recolor(color_func=get_color_scale, random_state=3))
        plt.imshow(default_colors)
        plt.imshow(wordcloud)
        plt.title(figure_title, fontsize=30)
        plt.axis("off")
        
        ## Saving the image file.
        if not os.path.exists(outfolder):
            os.makedirs(outfolder)
        figure_filename = "wordle_tp"+"{:03d}".format(topic) + ".png"
        plt.savefig(outfolder + figure_filename, dpi=dpi)
        plt.close()
    print("Done.")

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def generateWordCloud(node, contribs, wordsToShow=None, normalize=True, normMin=0, normMax=1):
    contrib = contribs[node]
    
    if (normalize):
        contrib = normalizeContrib(contrib, normMin, normMax)
    
    # generate text
    text = generateText(contrib, wordsToShow)
    
    # load mask
    d = path.dirname(__file__)
    circle_mask = imread(path.join(d, "black_circle_mask_whitebg.png"))
    
    # gen word cloud
    wc = WordCloud(background_color="white", max_words=2000, mask=circle_mask)
    wc.generate(text)

    # store to file
    wc.to_file(path.join(d, "node.png"))

    # show
    useColorFunc = False #normalize
    if (useColorFunc):
        plt.imshow(wc.recolor( color_func=pos_neg_color_func ))
    else:
        plt.imshow(wc)
        
    plt.axis("off")
    plt.show()

# 需要导入模块: from wordcloud import WordCloud [as 别名]
# 或者: from wordcloud.WordCloud import recolor [as 别名]
def draw_tag_cloud(users_tokens):
    from PIL import Image
    import matplotlib.pyplot as plt
    from wordcloud import WordCloud, ImageColorGenerator

    trump_coloring = np.array(Image.open("pics/trump.png"))

    freqs = get_full_frequencies(users_tokens)
    freq_pairs = freqs.items()
    wc = WordCloud(max_words=2000, mask=trump_coloring,
                   max_font_size=40, random_state=42)
    wc.generate_from_frequencies(freq_pairs)

    image_colors = ImageColorGenerator(trump_coloring)

    # plt.imshow(wc)
    # plt.axis("off")
    #
    # plt.figure()
    plt.imshow(wc.recolor(color_func=image_colors))
    # recolor wordcloud and show
    # we could also give color_func=image_colors directly in the constructor
    # plt.imshow(trump_coloring, cmap=plt.cm.gray)
    plt.axis("off")
    plt.show()