TRong Programing World

Sony QX-100開箱

2013-11-16T00:41:00.002-08:00

今天下午，訂購已久的商品終於出現了，網路上面開箱文也已經一大堆了，這邊僅做簡單的分享

包裝外觀，使用黑色筒形進行商品包裝

驗明正身，DSC-QX100

台灣原廠公司貨，提供24個月保固

開啟包裝外殼，中間就是今天的主角QX100

產品吊牌顯示支援NFC及WIFI Certified

QX100外觀

大大的SONY標誌

包裝內容物包含說明書、簡介說明、電池、吊帶及手機擴充夾具

打開被蓋可為電池置放處，這邊也包含如果不是使用NFC進行配對時的密碼

使用Sony N電池

外觀

開啟ZEISS外殼後可以看到記憶體及microUSB連接孔及重新設置紐，記憶體部分支援microSDHC及sony自家M2記憶卡

如果使用NFC進行連線配對，若該手機尚未安裝PlayMemories軟體，則會自動帶你前往下載此APP，若已經完成安裝，程式會自動將配對訊息進行設定，並將相機開啟及PlayMemories軟體，開啟軟體後會新增QX100及自動連線

連線後相機畫面將會直接顯示在螢幕上面，目前軟體功能較為陽春，上面可以顯示目前的對焦方式(AF-S)，記憶體放置情況，拍攝畫素(18M)拍攝模式，放大縮小及拍照。

拍照模式共分為智慧式自動、高級自動、P程式自動及光圈優先拍攝。

程式自動可以依據曝光值進行調整

光圈優先模式則可以自訂光圈值。

Mode模式中可以選擇要拍照還是錄影

其他設定如下，並可以關閉拍照聲音。

拍攝完畢後會自動將檔案傳至手機中

以上實際拍攝還沒有進行測試。結論網路上面已經有很多了，這邊就不再多做加油添醋的動作了，只能說SONY改變了相機的方式(形狀)創造出一個新的拍攝方式，因此會熱買也是可預期的，但因為透過wifi進行畫面連接，所以偶爾還是會出現螢幕Lag的現象，但大致上都還可以接受。

Sony WG-C20[紫色]開箱測試

2013-11-16T00:21:00.001-08:00

台灣進行開箱動作

還不太了解該樣商品的功用嗎?先看看官方宣傳的影片

日本sony官方網站介紹

主要功能有下列四項

Wi-Fi 行動伺服器
DLAN媒體伺服器
多媒體伺服器(可於手機上串Full HD影片)
行動電源

該商品可以簡單做完區域網路內的檔案伺服器，用來交換檔案使用，並可支援手機、平板、筆記型電腦等資訊平台，WG-C20內建NFC感應，可透過NFC快速進行連線配對，並提供專屬android軟體File Manager軟體方便進行檔案管理。

開箱了，首先我所購買的為紫色的版本，這次販賣共有黑、白及紫色，由於Z1也是購買紫色，所以這邊也選購紫色來進行搭配。

包裝內容物包含保固書(在台灣就屬水貨了保固應該就無效了)，USB充電線、說明書、及WG-C20主體

正面，大大的SONY Logo及NFC感應標誌

上側包含一個USB介面用來連接隨身碟或是當作行動電源使用，Micro USB用來幫本身充電使用，及指示等(讀取燈wifi、連線指示燈及電源指示燈)

側面包含電源開關(長按開機、開機後長按3秒為行動電源模式、長按為關機)，及SD卡讀卡機

背面是本產品的敗筆，為何要在中間做一條分隔線呢??

外觀看完了，介紹一下軟體部分吧，首次連線可以透過NFC進行配對，因此如果你的手機無法支援NFC，這樣你將無法順利登入主機，並取得設定權限。當感應NFC之後手機會自動開啟File Manager軟體，如果沒有安裝會自動跳至Google Play進行下載，但本產品因為台灣尚未上市的關係，所以你會發現該軟體還沒有辦法在台灣下載使用，好吧只好透過翻牆軟體把apk下載來安裝了，不會翻牆的，可以直接使用下面網址下載sony File Manager

下載: http://cht.tw/h/2qrva

請使用上列所提供之網址下載安裝，再度使用NFC感應進行連線，PWS(WG-C20)主機將進行初始化，並設定成功後會自己重新開機，這個過程需要等比較久的時間，等初始化之後將可以正常使用。

當設定完成後手機會自動重新連線，並顯示確定已完成設定

首次登入系統會警告目前的WIFI尚未進行加密動作，會有安全之疑慮，煩請進入設定，並設定WIFI加密方式與密碼

當初使畫完成後 File Manager軟體畫面如下，主要可以針對SD卡內容、USB內容及手機內容進行讀取複製等功能

點選右上較設定可以進行相關設定，可設定選項如下圖

1.安全性設定
首先於安全性可以設定WIFI加密的方式，可以避免其他使用者輕鬆連入，安全性設定選擇WAP，軟體將可讓你自訂連線密碼。

設定完成後系統會重新開機，重新開機後您必須使用上述密碼才能登入主WG-C20，但若使用NFC則可自動幫您輸入連線密碼。

設定安全性之後會顯示目前為WPA2加密方式

2.網路設定

網路設定主要讓您的WG-C20主機與目前既有無線基地台進行連線，這樣的好處可以讓廉讓WG-C20的手機、平板電腦、電腦等裝置一樣可以有網路的功能，若無設定網路，用戶僅可以在WG-C20中存取檔案資料使用。

3.存取控制

存取控制主要將WG-C20再開一個訪客無線網路連線的基地台，並可讓你設定新的密碼，以及訪客僅可以瀏覽的檔案位置，這樣用來簡單控管訪客來訪的資料夾。

4.電力控制

電力控制用來顯示目前還有多少電力

5.WPS設定

這裡可以設定WPS相關資訊，包含名稱等，注意這邊WPS主機會在你第一台使用NFC進行連線時的那台裝置當作是管理員，只有這台裝置可以進入設定，因此如果要變更管理員，則必須重製PWS回原廠設定值再重新配對，或是按下主機上之reset按鈕進行重製

6.DLAN媒體伺服器

DLAN為新一代串流技術，可以透過只方式讓支援DLAN的主機進行連線，並取得影像或音樂等相關資料，因此當你放入新的多媒體檔案後，必須更新資料庫，或重建資料庫的動作，遠端主機才能夠正確讀取到媒體伺服器中之檔案。

7.顯示

顯示功能用來讓媒體伺服器產生預覽圖示之使用，可以進行相關檔名之關聯，讓使用者可以輕鬆取得相關資料。

8.系統資訊

系統資訊包含版本資料、韌體更新及相關授權說明。

系統測試

手機File Manager APP 檔案複製

簡單要做檔案複製可以進入檔案瀏覽畫面，並在要複製之檔案上點擊停留兩秒鐘，將可以開啟複製功能

點選複製按鈕將可以自動開啟要複製至哪個位置之選項，因此可以做手機對USB複製，手機對SD卡，SD卡對USB等相關連複製。

筆記型電腦連線測試

在筆記型電腦中你可以發現於無線網路中會連結到兩台WG-C20媒體伺服器，其中一台維Guest開頭，這代表訪客使用的媒體伺服器，建議兩個密碼設定不相同，以防止訪客存取較重要之資料，首先點選Guest-WG-C20進行連線,訪客模式進行測試。

連線後於區域網路內會發現WG-C20這台網路空間可以使用

登入後將可以看到分享之資料夾，但由於是訪客模式的關係，你只可以瀏覽上面安全性設定的資料夾。

安全性設定之共用資料夾如下，這邊可以讓訪客任意上傳及下載檔案

使用一般模式登入測試。

使用一般模式登入將可以直接看到WG-C20中之SD卡及USB裝置之所有檔案，因此你可以對這兩個裝置中之檔案進行複製及刪除動作

另外因為支援DLAN之關係，該媒體伺服器將可以直接瀏覽上面之影像、影片及音樂資料。

桌上型電腦測試

如果你在網路連線中有與家中之無線基地台做連線，這樣你的區域網路將可以讀取到該設備，但這邊Sony WG-C20安全性就做的沒有那麼好了，使用區域網路直接登入的就是一般使用者的權限，也就是說所有資料夾都可以進行讀寫的動作。

當然連線後可以在網路位置上發現已經新增WG-C20這一台網路位置，可以直接點選進入

這邊較可惜的是因為這是日本公司貨，所以裡面預設的韌體都是日文，因此資料夾表示也是使用日文做表示，希望在台灣正式開賣後可以讓使用者更新韌體去更新為繁體中文。

手機連線訪客模式

如果手機連線所使用的是訪客模式，則出現的資料夾將是安全性設定之對應資料夾，相同的使用者也只可以在這邊進行檔案複製

另外WG-C20並非所以有一般使用者都可以進入設定畫面，如果你使用一般使用者登入，但非第一次所連線之手機，擬將不會出現設定之按鈕，也就是說你只可以看PWS的相關資訊，無權力進行相關設定，必須是第一次配對之裝置才可以進行所以有之設定

後記，為什麼會想買這個裝置呢?首先愛好攝影的我，通常會在攜帶一台android平板出門，住要可以透過SD卡及OTG裝置將檔案進行備份，而此裝置可以直接透過SD讀卡機與USB裝置進行讀取，可以省去要再多攜帶一台裝置出門之問題，而這台WG-C20雖然有USB孔，可以支援USB隨身碟，但如果要使用2.5吋硬碟目前測試上還是推不動，除非使用外掛式電源才有辦法進行讀取，另外USB隨身碟的檔案格式必須要為FAT32才有辦法進行掛載，後續會在使用較省電之2.5吋外接硬碟進行測試，到時候會在放上與大家分享。

Play Store大特價"End of Summer Sale"

2012-09-01T00:36:00.000-07:00

最近Google Play Store又提供了一系列的付費遊戲軟體大降價了，Play Store 內有 16 個Apps/Games 推出減價，部份減幅更達 80%。如果下面遊戲是你正物色很久的，但遲遲尚未下手的，這次特價，就給他買回來了吧。

Beautiful Widgets(NT$25.87)
Business Calendar (NT$29.62)
Crystal Defenders (NT$37.69)
Draw Race 2 (NT$29.63)
The Game of Life (NT$ 29.63)
Gangstar Rio: City of Saints (里約熱內盧：聖徒之城 NT$ 29.63)
iBlast Moki 2 (NT$ 29.63)
The Lorax – Dr. Seuss (NT$ 29.63)
Me Too! – Little Critter (NT$ 29.63)
Modern Combat 3: Fallen Nation (現代戰爭 3：墮落國度NT$ 29.63)
N.O.V.A. 3 (N.O.V.A. 3：近軌道先鋒聯盟NT$ 29.63)
Spirits (NT$25.87)
Star Chart (NT$32.66)
Super Dynamite Fishing (Premium) (NT$25.87)
SwiftKey 3 Keyboard (NT$32.66)
Vignette (NT$32.66)
Virtua Tennis Challenge (NT$29.63)
Zen Bound 2 (NT$25.87)

台灣如何購買請看上一篇文章

http://geoprograming.blogspot.tw/2012/09/bluestacksandroid.html

透過BlueStacks購買Android付費軟體

2012-09-01T00:19:00.004-07:00

在台灣使用Android系統，因為台北市政府的關係，導致Google出走台灣已經一段時間了，我看目前要恢復付費功能，在短時間內應該沒有辦法了，山不轉路轉，今天教大家如何透過新增一台BlueStacks模擬器，讓你可以購買付費軟體，首先你必須先前往下載BlueStacks。

官方網站:http://bluestacks.com/

點選Download Now進入下載頁面

安裝步驟很簡單，就不斷地點選下一步即可，安裝完成後你將可以在Windows環境下模擬出一台Android裝置，如下圖。

接下來需登入您的Google帳號已註冊你的Android裝置，點選右下角的設定，並點選Manage Accounts 登入你的Google帳號。

完成此動作之後，請回到電腦中，利用瀏覽器開啟 https://play.google.com/apps 進入Play商店中的我ANDROID應用程式，此時你將會發現新增了一台"T-Mobile Samsung GT-N7000"裝置，該裝置使用T-Mobile作為sim卡，所以你在台灣還是可以裡用他購買付費軟體。

當你新增完成之後就快要接近可以購買付費軟體的動作了，接下來你要在Google新增你的信用卡資訊，請進入Google Wallet，Google電子錢包網站

https://wallet.google.com/manage/#transactions:

並於付款方式填入你的信用卡資訊

接下來你就可以購買一個付費軟體了，首先一樣使用Windows中之瀏覽器，並搜尋一付費軟體

此時你會發現購買的金額出現了，並且下面的相容性出現了可以購買的選項了

觀看詳細資訊，你會發現"T-Mobile Samsung GT-N7000"這個裝置是可以購買的，接下來你就可以點選購買進行軟體購買的動作了

確認無誤請點選繼續進入購買

若你無出現Google Wallet訊息，代表你尚未新增任何信用卡，如果有將可以點選購買進入結帳

看到這裡你已經順利購買成功了。並且於虛擬機中也已經順利安裝成功了

當在其他裝置購買之後，如何在真實的機器中進行安裝呢?首先進入Play Store，點選我的應用程式，再點選全部，此時你將可以看到你所購買的應用程式，並且會顯示已購買，若你的系統可以支援該軟體，將可以出現安裝的畫面。用這樣的方式購買到底有沒有風險，當然部分因為平板的關係，有些遊戲是不支援的，如果你出現下面畫面，代表你的裝置不支援該軟體，建議你直接點選退款，進入退款步驟。

Sony Tablet S無法支援該遊戲，那只好讓我的Xperia S玩了，利用上述相同的方式進入安裝

結論:

目前因為台北市政府與Google play Store的退費機制談不攏，導致Google放棄了台灣這個市場，利用這樣的方式可以讓你不需刷機，不需要root，也不需要使用國外的sim卡就可以購買，目前使用這樣的方式幾乎什麼軟體都可以進入購買，並且不會出現任何錯誤，或是不能交易的問題，但用此方式購買的軟體，如果有更新訊息，play Store將不會自動更新，你必須回到安裝的畫面，如果有提示更新，再進行更新的動作，目前大概就只有這一點較不方便，其餘該方式真的是一個不錯購買付費軟體的方式。

[Qt] - built-in 對話方塊

2012-08-07T22:46:00.002-07:00

Qt內建了一些程式設計師常常會使用到的一些對話方塊，其中包含顏色選取檔案瀏覽等等。這些都屬於固定式的對話視窗，當你要使用時將可以直接使用Qt內建之對話方塊進行選取即可。本章捷將介紹Qt內建之(built-in)方塊。

Qt除了內建QMesseageBox訊息方塊外，Qt也提供了其他的內建方塊，其中包含

QColorDialog：色彩選取工具。
QErrorMessage：顯示錯誤訊息視窗。
QFileDialog：檔案選取視窗。
QFontDialog：使用者選取字型工具。
QInputDialog：使用者簡單輸入工具。
QPageSetupDialog：配置印表機選項。
QProgressDialog：處理程序進度列。
QPrintDialog：印表機列印方塊

Step1.

首先你要新增一個TextEdit及八個PushButton，相關Object名稱及屬性如下表所示，並將ui設計如下圖所示。

Label Object ObjectName

QTextEdit displayTextEdit

Color QPushButton color_B

Message QPushButton Message_B

File QPushButton File_B

Font QPushButton Font_B

Input QPushButton Input_B

Page Setup QPushButton PageSetup_B

Progress QPushButton Progress_B

Print QPushButton Print_B

Step2.

include所需之檔案，於mainwindow.hpp中加入#include <QtGui/QDialog>，及mainwindow.cpp檔案中加入#include <QtGui/QtGui>。

Step3.

於個別button中加入相關程式碼。

Color

QPalette palette = ui->displayTextEdit->palette();
    const QColor& color
            = QColorDialog::getColor(palette.color(QPalette::Base), this);
    if(color.isValid())
    {
        palette.setColor(QPalette::Base, color);
        ui->displayTextEdit->setPalette(palette);
    }

執行結果如下圖所示。

Message

QErrorMessage box(this);
    box.setWindowTitle(tr("MessageBox"));
    box.showMessage(tr("MessageBox xx));
    box.showMessage(tr("MessageBox xx));
    box.showMessage(tr("MessageBox xx));
    box.showMessage(tr("MessageBox yy));
    box.showMessage(tr("MessageBox zz));

    box.exec();

執行結果如下圖所示。

File

QString fileName = QFileDialog::getOpenFileName(this,
                                    tr("Open File"),
                                    "/home/trong/",
                                    tr("Any File(*.*)"
                                    ";;Text File(*.txt)"
                                    ";;XML File(*.xml)"));
    ui->displayTextEdit->setText(fileName);

執行結果如下

Font

bool ok;
    const QFont& font = QFontDialog::getFont(&ok,
                             ui->displayTextEdit->font(),
                             this,
                             tr("Font Select box"));
    if(ok)
    {
        ui->displayTextEdit->setFont(font);
    }

執行結果

Input

bool ok;
    QString text = QInputDialog::getText(this,
                                    tr("Input"),
                                    tr("Input Text:"),
                                    QLineEdit::Normal,
                                    QDir::home().dirName(),
                                    &ok);
    if (ok && !text.isEmpty())
        ui->displayTextEdit->setText(text);

執行結果

Page Setup

QPrinter printer;
    QPageSetupDialog dlg(&printer, this);
    dlg.setWindowTitle(tr("Page Setup Box"));
    if (dlg.exec() == QDialog::Accepted)
    {
            // GO To Next process
    }

Progress

QProgressDialog progress(tr("Processing..."), tr("Cancel"), 0, 10000, this);
    progress.setWindowModality(Qt::WindowModal);
    progress.setWindowTitle(tr("Processing Box"));
    progress.show();
    for (int i = 0; i < 10000; i++)
    {
            progress.setValue(i);
            qApp->processEvents();
            if (progress.wasCanceled())
                    break;
            //
            qDebug() << i;
    }
    progress.setValue(10000);

Print Page

QPrinter printer;
    QPrintDialog dlg(&printer, this);
    dlg.setWindowTitle(tr("Print Box"));
    if (dlg.exec() == QDialog::Accepted)
    {
            // next processing
    }

參考文獻:精通Qt4視窗介面程式開發與設計

http://www.books.com.tw/exep/prod/booksfile.php?item=0010516429

[Qt] - Dialog 排版

2012-08-07T01:42:00.003-07:00

在這個章節裡面，我們將教導你們如何去產生一個Dialog視窗，並且如何去做簡單的排版。首先先建立一個Qt GUI application專案，這邊與我們之前所建立之MainWindow方式有點不同，因為我們要建立一個Dialog專案，所以必須在Class infomation設定中，將Base class選擇QDialog，如下圖所示。

接下來新增幾個ui物件。1.TexeLabel、2.Line Edit、3. Horizontal Spacer、4.pushButton。其排列方式如下。

ui物件相關屬性修改如下

ui物件 objectName label

1.TexeLabel label Cell Location:

2.Line Edit lineEdit

3. Horizontal Spacer

4.pushButton okButton OK

5.pushButton cancelButton Cancel

按住"Ctrl"並點選ui物件""textLabel與LineEdit後，點選滑鼠右鍵開啟選單，點選Layout->LayOut Horizontally進行水平排列，再利用相同方式點選"Horizontal Spacer"及兩個"pushButton"並利用相同方式進行水平排列，最後將兩個進行水平排列之物件，利用相同方式Layout->LayOut Vertically 進行垂直排列，做完上述動作之後所有ui物件將完成較規則的排列方式。如果你覺得物件間的距離還不是很好，你可以再度點選Layout->Adjust Size進行重新排列大小，其結果如下所示。

輸入表單中同常伴隨Tab按鍵進行物件間資切換，此時你可以編輯你的tab順序，點選Edit->Edit Tab Order進入編輯畫面。

此時將出現tab編輯畫面，畫面中之1、2、3所代表的就是你點選tab按鈕時，所切換的順序，你可以點選你要的位置，進行編輯順序，編輯還成後點選"F3"恢復Edit Widgets介面。

UI介面設計完成之後，如果你要先觀看該UI介面是否如你預期的結果，你可以點選Tools->Form Editor->Preview進行預覽。

接下來建立幾個簡單上面建立之UI之基本動作，打開dialog.cpp檔案，假設我們預先設定lineEdit在未輸入文字的時候不可以按下ok按鈕，並且限定lineEdit中第一個字只可以輸入英文單字，第二三只可以輸入數字，且只能輸入這三個字，那要如何進行設計呢?

於dialog.cpp檔案中新增下列程式碼。

  //預先將okButton按鈕進行關閉動作
ui->okButton->setEnabled(false);

  //設定一regExp屬性，改屬性中限制，第一個單字[A-Za-z]也就是說只可以輸入英文單字，第二格[1-9]只能輸入數字1-9，第三個[0-9]只能輸入數字，最後{0,2}代表輸入字元由0-2也就是三個字元，並將該屬性設定給lineEdit使用
    QRegExp regExp("[A-Za-z][1-9][0-9]{0,2}");
    ui->lineEdit->setValidator(new QRegExpValidator(regExp,this));

  //最後新增按鈕動作，下列方式均可以將Dialog進行關閉，而acceot(0將可於QDialog::Accept()回傳1，reject則回傳0，利用該方式可以進行動作傳遞
    connect(ui->okButton,SIGNAL(clicked()),this,SLOT(accept()));
    connect(ui->cancelButton,SIGNAL(clicked()),this,SLOT(reject()));

最後於lineEdit ui上面點選右鍵，Go to slot，點選textChanged(QStrong)進行新增動作，該動作將於lineEdit輸入文字後啟動，該啟動內容主要判定lineEdit有輸入文字，且輸入文字都符合上面regExp規則的話，將okButton啟用，其程式碼如下所示。

ui->okButton->setEnabled(ui->lineEdit->hasAcceptableInput());

執行結果如下

接下來我們嘗試處理按鈕按下後的事件，按鈕按下的事件你可以使用點選右鍵的方式新增Go to slot的方式建立點擊事件，也可以如我上述所使用之方式，直接用SLOT的方式指定要執行的指令。我們在這邊預計讓你點選ok之後會出現一個MessageBox視窗，顯示OK訊息。點選Cancel按鈕之後會出現警告視窗，會出現警告視窗，問你是否關閉。首先在dialog.hpp檔案中include QMessageBox函式庫進來。

#include <QMessageBox>

接下來在private:中加入

void accept();
void reject();

再開啟dialog.cpp檔案，並於最下方輸入該兩個動作所要執行的內容，建立MessageBox的方式很簡單，你可以直接使用QMessageBox來建立QMessageBOX::後面所帶的屬性為MessageBox所顯示的圖示，其中包含about、aboutQt、infomation、question、warning、critical等。輸入屬性(QWidget *parent,const QString &title,const QString &text)，使用方式如下。

//accept動作
void Dialog::accept()
{
    QMessageBox::about(this,tr("ok"),tr("ok"));
}

//reject動作
void Dialog::reject()
{

    QMessageBox box;
    box.setWindowTitle(tr("Exit!"));
    box.setIcon(QMessageBox::Question);
    box.setText(tr("Are you sure want to cancel?"));
    box.setStandardButtons(QMessageBox::Yes|QMessageBox::Cancel);
    box.setDetailedText(tr("test"));
    switch(box.exec())
    {
        case QMessageBox::Yes:
QDialog::done(1);
            break;
        case QMessageBox::No:

            break;
    }
}

第二個動作reject中，相同使用QMessageBox的方式建立，但比較不相同的地方在於我們直接設定相關屬性，該方式可以讓你針對該屬性一一進行設定，並於最後用switch的方式來判定所按下的按鈕，並執行想要執行的指令，其做法如上所示。

MessageBox::about

MessageBox::question

MessageBox::warrning

MessageBox::infomation

MessageBox::critial

[Qt] - Create menu bar with QT

2012-08-07T01:22:00.004-07:00

在前幾個章節我們都用Button的方式來教導大家如何讓OpenCV去執行，該方式可以讓你們較快速的學習如何再QT裡面達成我們要的指令，那接下來我們必須使用比較正規的做法去編寫你的GUI介面了，再目前很多程式軟體裡面，通常你都會看到menu選單，讓你可以下拉去點選你要的動作，今天這個章節將利用menu的方式，讓你將你要的功能給編寫出來。

Step1：建立一QT GUI Application

建立的方式與前幾個章節一樣，這邊將不再多做說明。開啟後一樣在pro檔案中將opencv函數進行include動作。

Step2：開始進行menu建立

於QT中要建立menu選單之動作其實非常簡單，於Design畫面中你可以看到Type Here，於此點選滑鼠左鍵兩下將可進入編輯新增畫面，於此你可以輸入該選單的名稱，如下圖所示。

這裡於第一層輸入File

第二層輸入Open File。並於Action Editor視窗中點選滑鼠右鍵，並點選Edit按鈕進行編輯。

進入Edit Action介面之後，你將可以看到Text：顯示的文字、Object name：物件名稱等等，比較特別的就是Shortcut：這是你將可以使用熱鍵的方式進行該按鈕動作，本按鈕為開啟檔案，所以我將它設定為"Ctrl"+"O"。編輯完畢點選OK離開。

編輯該按鈕動作，你可以點選右鍵，並點選Go To Slot進入。

按鈕動作選取triggered()

新增之後你將可以在on_actionOpen_File_triggered()，中新增你要的動作

注意：下列程式碼當中使用第二課中所用到之開啟檔案方式，因此相關include與UpdateImage及table標籤要記得加入才可以執行。

相關程式碼如下

QString fileName = QFileDialog::getOpenFileName(this,
     tr("Open Image"),".",tr("Image File (*.png *.jpge *.jpg *.bmp"));
    image = cv::imread(fileName.toAscii().data());
    result=image;
    if(image.data){
        cv::cvtColor(result,result,CV_BGR2RGB);
        UpdateQImage(result);
    }

Step3：簡單測試

執行後畫面如下，利用"Ctrl"+"O"，將可以順利開啟該影像。

結果如下。

視窗標題"MainWindow"要如何修改呢?請直接修改windowTitle之值，如OpenCV With QT

Step4：將已經編寫好的檔頭及程式碼載入

在第三課我們已經介紹如何簡單編寫一些屬於我們自己的程式庫了，那在新的專案裡面要如何直接將他載入呢?首先將那兩個檔案複製到新專案之src資料夾當中

在Headers與Sources中點選右鍵，點選"Add Existing Files..."。

並分別加入cvcore.h及cvcore.cpp兩個檔案，加入後如下圖所示將會出現那兩個檔案。

此時會到QT_GUI_Opencv.pro檔案，將可發現QT已經自動幫你加入此兩個檔案到SOURCES及HEADERS裡面了。

要使用此函式庫當然要將他include進來，回到mainwindow.hpp檔案裡面，新加入#include "cvcore.h"，這樣你就已經將此函式庫成功加入了。

Step5：新增其他影像處理之menu

使用上述所教新增menu之方式，再度新增Process，及第二層Flip選單。相同新增一個triggered動作

執行結果如下

Step6：開始建立自己的按鈕動作(edit)

在step5中我們只是示範要如何將函數給放到menu上面去執行，從這邊開始將介紹依序建立一些你所要的功能。首先我們編輯edit，並在裡面新增Restore Origional image、Flip horizontally、Flip Upside Down及Contrast Brightness，四個動作。並分別對這些動作賦予所對應之動作。

相關使用函數如下：

Restore Origional image

該動作將原始影像回復，新增按鈕triggered之後在裡面編輯如下。

void MainWindow::on_actionRestore_Origional_Image_triggered()
{
result=image;
UpdateQImage(result);
}

Flip horizontally

水平翻轉

void MainWindow::on_actionFlip_Horizontally_triggered()
{
result=IPtool.flip(result,1);
UpdateQImage(result);
}

Flip Upside Down

垂直翻轉

void MainWindow::on_actionFlip_Upside_Down_triggered()
{
result=IPtool.flip(result,-1);
UpdateQImage(result);
}

Contrast Brightness

亮度/對比色彩調整

上面水平翻轉功能，我們已經於cvcore中已經新增過了，所以不需要在新增，而Contrast Brightness在本程式中屬於位定義之函式，所以我們要在cvcore.h及cvcore.cpp中加入處裡的程式碼，其程式碼如下表所示

cvcore.h

// Contrast & brightness adjustment
    cv::Mat contast_brightness(const cv::Mat &image, const double &alpha, const int &beta);
    cv::Mat contast_brightness(const cv::Mat &image);

cvcore.cpp

cv::Mat CVCore::contast_brightness(const cv::Mat &image, const double &alpha, const int &beta) {
    image.convertTo(result, -1,alpha,beta);
    return result;
}

mainwindow.cpp

void MainWindow::on_actionContrast_Brightness_triggered()
{
    result=IPtool.contast_brightness(result,1.5,100);
    UpdateQImage(result);
}

按照上述方式，將可以成功完成四個動作。

Step7：建立Filtering menu

接下來再新增幾項opencv處裡影像的方式，其新增內容如下所式

Filtrting ->Sharpen

->Customeringed Filt

->Smoothing->Homogeneous Blur

->Gaussian Blur

->Median Blur

->Bilateral Filter

Sharpen

銳利化影像

cvcore.h

// Sharpen image
    cv::Mat sharpen(const cv::Mat &image);

cvcore.cpp

cv::Mat CVCore::sharpen(const cv::Mat &image) {
    cv::Mat kern = (cv::Mat_<char>(3,3) <<
                     0,-1,0,
                    -1, 5,-1,
                     0,-1,0);
    filter2D(image, result, image.depth(), kern);
    return result;
}

mainwindow.cpp

void MainWindow::on_actionSharpen_triggered()
{
    result=IPtool.sharpen(result);
    UpdateQImage(result);
}

Customeringed Filt

自行定義一個濾鏡

cvcore.h

cv::Mat filtering(const cv::Mat &image, const cv::Mat &kern);

cvcore.cpp

cv::Mat CVCore::filtering(const cv::Mat &image, const cv::Mat &kern) {
    filter2D(image, result, image.depth(), kern);
    return result;
}

mainwindow.cpp

void MainWindow::on_actionCustomeringed_Filt_triggered()
{
    cv::Mat kern =(cv::Mat_<char>(3,3)<< 0,-1,0,-1,5,-1,0,-1,0);

    result=IPtool.filtering(result,kern);
    UpdateQImage(result);
}

Homogeneous Blur

同質模糊

cvcore.h

// Homogenous Blur Filter
    cv::Mat HomogenousBlur(const cv::Mat &image, const int &MaxKern);

cvcore.cpp

cv::Mat CVCore::HomogenousBlur(const cv::Mat &image, const int &MaxKern) {
    cv::blur(image,result,cv::Size(MaxKern,MaxKern),cv::Point(-1,-1));
    return result;
}

mainwindow.cpp

void MainWindow::on_actionHomogeneous_Blur_triggered()
{
    result=IPtool.HomogenousBlur(result,5);
    UpdateQImage(result);
}

Gaussian Blur

高斯模糊

cvcore.h

// Gaussian Blur Filter
cv::Mat myGaussianBlur(const cv::Mat &image, const int &MaxKern);

cvcore.cpp

cv::Mat CVCore::myGaussianBlur(const cv::Mat &image, const int &MaxKern) {
    cv::GaussianBlur(image,result,cv::Size(MaxKern,MaxKern),0,0);
    return result;
}

mainwindow.cpp

void MainWindow::on_actionGaussian_Blur_triggered()
{
    result=IPtool.myGaussianBlur(result,5);
    UpdateQImage(result);
}

Median Blur

中質模糊

cvcore.h

// Median Blur Filter
    cv::Mat MedianBlur(const cv::Mat &image, const int &MaxKern);

cvcore.cpp

cv::Mat CVCore::MedianBlur(const cv::Mat &image, const int &MaxKern) {
    cv::medianBlur(image,result,MaxKern);
    return result;
}

mainwindow.cpp

void MainWindow::on_actionMedian_Blur_triggered()
{
    result=IPtool.MedianBlur(result,5);
    UpdateQImage(result);
}

Bilateral Filter

cvcore.h

// Gaussian Blur Filter
    cv::Mat BilateralBlur(const cv::Mat &image, const int &MaxKern);

cvcore.cpp

cv::Mat CVCore::BilateralBlur(const cv::Mat &image, const int &MaxKern) {
    cv::bilateralFilter(image,result,MaxKern,MaxKern*2,MaxKern/2);
    return result;
}

mainwindow.cpp

void MainWindow::on_actionBilateral_Filter_triggered()
{
result=IPtool.BilateralBlur(result,5);
UpdateQImage(result);
}

這樣上述的影像處理步驟就已經結束了，其中每個函式中都有不同的參數，該參數之設置方式差異，將引響影像處理後的結果，因此要如何給定這些參數，將可使用horizontalSlider的方式來解決

filter2D

Convolves an image with the kernel.

C++: void filter2D(InputArray src, OutputArray  dst, int ddepth, InputArray kernel, Point anchor =Point(-

1,-1), double delta=0, int borderType=BORDER_DEFAULT )

Python:  cv2. filter2D(src, ddepth, kernel [, dst [, anchor [, delta [, borderType ] ] ] ]) → dst

C: void cvFilter2D(const CvArr* src, CvArr* dst , const CvMat* kernel, CvPoint anchor=cvPoint(-1, -1))

Python:  cv. Filter2D(src, dst, kernel, anchor=(-1, -1) ) → None

Parameters

src – Source image.

dst – Destination image of the same size and the same number of channels as src .

ddepth – Desired depth of the destination image. If it is negative, it will be the same as

src.depth() .

kernel – Convolution kernel (or rather a correlation kernel), a single-channel floating point matrix. If you want to apply different kernels to different channels, split the image into separate color planes using split() and process them individually.

anchor – Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor should lie within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center.

delta – Optional value added to the filtered pixels before storing them in dst .

borderType – Pixel extrapolation method. See borderInterpolate() for details.

blur

Smoothes an image using the normalized box filter.

C++: void blur(InputArray  src, OutputArray dst, Size ksize, Point  anchor=Point(-1,-1), int  border- Type=BORDER_DEFAULT  )

Python:  cv2. blur(src, ksize [, dst [, anchor [, borderType ] ] ]) → dst

Parameters

src – Source image.

dst – Destination image of the same size and type as src .

ksize – Smoothing kernel size.

anchor – Anchor point. The default value Point(-1,-1) means that the anchor is at the kernel center.

borderType – Border mode used to extrapolate pixels outside of the image. The function smoothes an image using the kernel:

The call blur(src, dst, ksize, anchor, borderType) is equivalent to boxFilter(src, dst, src.type(), anchor, true, borderType) .

See Also:

boxFilter(), bilateralFilter(), GaussianBlur(), medianBlur()

GaussianBlur

Smoothes an image using a Gaussian filter.

C++: void GaussianBlur(InputArray src, OutputArray  dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT )

Python:  cv2. GaussianBlur(src, ksize, sigma1 [, dst [, sigma2 [, borderType ] ] ]) → dst

Parameters

src – Source image.

dst – Destination image of the same size and type as src .

ksize – Gaussian kernel size. ksize.width and ksize.height can differ but they both must be positive and odd. Or, they can be zero’s and then they are computed from sigma _* .

sigmaX – Gaussian kernel standard deviation in X direction.

sigmaY – Gaussian kernel standard deviation in Y direction. If sigmaY  is zero, it is set to be equal to sigmaX  . If both sigmas are zeros, they are computed from ksize.width and ksize.height , respectively. See getGaussianKernel() for details. To fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ksize , sigmaX , and sigmaY .

borderType – Pixel extrapolation method. See borderInterpolate() for details. The function convolves the source image with the specified Gaussian kernel. In-place filtering is supported. See Also:

sepFilter2D(), filter2D(), blur(), boxFilter(), bilateralFilter(), medianBlur()

medianBlur

Smoothes an image using the median filter.

C++: void medianBlur(InputArray src, OutputArray  dst, int ksize)

Python:  cv2. medianBlur(src, ksize [, dst ]) → dst

Parameters

src – Source 1-, 3-, or 4-channel image. When ksize is 3 or 5, the image depth should be

_CV ^__{8U , CV}^__{16U , or CV}^__{32F . For larger aperture sizes, it can only be CV} ^__{8U .}

dst – Destination array of the same size and type as src .

ksize – Aperture linear size. It must be odd and greater than 1, for example: 3, 5, 7 ...

The function smoothes an image using the median filter with the ksize × ksize aperture. Each channel of a multi-

channel image is processed independently. In-place operation is supported.

See Also:

bilateralFilter(), blur(), boxFilter() , GaussianBlur()

bilateralFilter

Applies the bilateral filter to an image.

C++: void bilateralFilter(InputArray src, OutputArray  dst, int d, double sigmaColor, double sigmaS- pace, int borderType=BORDER_DEFAULT )

Python:  cv2. bilateralFilter(src, d, sigmaColor, sigmaSpace [, dst [, borderType ] ]) → dst

Parameters

src – Source 8-bit or floating-point, 1-channel or 3-channel image.

dst – Destination image of the same size and type as src .

d – Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace .

sigmaColor – Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in larger areas of semi-equal color.

sigmaSpace – Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is proportional to sigmaSpace .

The function applies bilateral filtering to the input image, as described in http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters.

Sigma values: For simplicity, you can set the 2 sigma values to be the same. If they are small (< 10), the filter will not have much effect, whereas if they are large (> 150), they will have a very strong effect, making the image look “cartoonish”.

Filter size: Large filters (d > 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering.

[Qt] - 建立自己的class

2012-08-06T21:23:00.000-07:00

建立自己的class

Part 1

延續上一個章節，我們可以開始組自己的class程式，並將該class放置在自己建立的檔案當中，如果未還有其他程式需要用到，那就可以直接include 這個檔案，就可以再度使用這個class了。這邊假設我們要建立一個新的檔案，該檔案必須要有一個檔頭檔(.hpp)與程式碼(cpp)這兩個檔案，新增方式如下圖

Haders右鍵，點選Add New...，並選擇C++ ，C++ Header File，如下圖所示

Name地方輸入你要的檔頭名稱

點選Finish結束新增

回到mainwindiw.hpp檔案中，我們必須將檔投給include進來，如下圖所示。

打開剛剛所新增的檔案cvcore.h，並開示進行檔頭編寫動作，其空白檔頭只會有下面這幾行字，我們必須在這幾行字中進行編寫。

接下來我們新增一個最簡單的Filp應用，其相關程式如下圖所示，其中包含我們要建立的Class ，該Class名稱為CVCore。

cvcore.h

#ifndef CVCORE_H
#define CVCORE_H

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>

//建立我們自己的class 名稱為CVCore
class CVCore
{
//於該私有變數裡面，新增result變數，該變數屬於cv::Mat類別
private:
    // image containing resulting image.
    cv::Mat result;

public:

    // Flip an image.
    cv::Mat flip(const cv::Mat &image);

};

#endif // CVCORE_H

接下來要加入原始碼.cpp檔案於Sources點右鍵，新增C++ Sources File檔案，如下圖所示。

檔名為cvcore.cpp

以下我們建立一個最簡單的flip的class，其程式碼如下圖所示。

#include "cvcore.h"

cv::Mat CVCore::flip(const cv::Mat &image) {
    cv::flip(image,result,1);
    return result;
}

最後我們必須修改mainwindow.hpp檔案，並加入一個字定義變數來承接CVCore 這個class類別，如下圖所示，利用該方式，以後輸入IPTool，及代表CVCore物件。利用IPTool變數來代表CVCore有個好處，那就是未來程式不怎麼修改，你知需要在檔頭部分，將IPTool修改成我們要的Class類別，這樣就可以輕鬆轉換了，不需要再到程式碼裡面去進行修改。

當上述動作都做完之後，我們就可以開始使用我們所建立的class了，請打開mainwindow.cpp，並編輯process image按鈕動作，將該動作改成"result=IPtool.flip(result);"，這樣就可以簡單輕鬆使用我們的程式碼了。

Part2

於上述動作中，其實Flip動作中可以讓使用這自訂Flip翻轉的參數設定，那我們要怎麼在自定義變數中增加一個資料結構，並使用這個資料結構中之變數來讓Flip執行不同翻轉的動作呢?首先你必須在cvcore.h檔案中之public變數中加入該資料結構的宣告，假設我們這邊自定義一個資料結構稱之為CVCore，那你將可以利用CVCore();進行資料結構宣告，並將會使用到之變數於private中進行宣告，這邊我們宣告一個FlipCode，作為動作判斷之變數，如下圖所示。

接下來開啟cvcore.cpp檔案，並將資料結構CVCore::CVCore之相關變數輸入，如下圖所示。

接下來可以加入該class，於cvcore.h中加入檔頭屬性，如下圖所示。

// Flip an image with FlipCode.
    cv::Mat flip(const cv::Mat &image, const int &FlipCode);

接下來可以在你的程式碼檔案中編寫該class動作了，開啟cvcore.cpp檔案，並加入程式碼如下圖所示。

cv::Mat CVCore::flip(const cv::Mat &image, const int &FlipCode) {
    cv::flip(image,result,FlipCode);
    return result;
}

程式碼都完成後，我們再新增另外一個按鈕，按鈕名稱為Button_Flip_Down，並新增按鈕動作，於程式碼中輸入上述程式指令，如下圖所示。

result=IPtool.flip(result,-1);
    UpdateQImage(result);

結果

原始

Flip Down

Sony Xperia S USB OTG大挑戰

2012-06-24T06:30:00.002-07:00

最近Sony Xperia S開始升級 Android ICS 4.0.4了，所以想說做一些簡單的USB OTG測試(其實之前2.3.7的版本就有了)，為什麼想要做這個測試呢?簡單來說，目前單眼相機拍照檔案都非常大，那如果出門在外好幾天，記憶卡又不夠用，又沒有攜帶筆記型電腦出門，該怎麼辦呢?所以以下做了一些測試，住要想把記憶卡裡面的資料全部複製到隨身碟(2.5吋)裡面。

主角登場 Sony Xperia S

看一下目前的版本Android ICS 4.0.4 版本號碼6.1.A.0.425

首先要準備甚麼東西呢?
1.USB-OTG線

2.各式USB隨身碟(USB2.0、USB3.0) SD記憶卡

3.行動電源(Power BankII 5000mAh)

4.2.5吋外接式硬碟(VANTEC NexStar3 200GB)

5.各式讀卡機(USB3.0&USB2.0)

6.USB2.0 HUB

7.HUB擴充電源線

先說明一下，因為Android架構為Linux為基礎的系統，所以目前對NTFS檔案格式還是無法支援，所以這邊所有的隨身碟、記憶卡均為FAT32檔案格式，測試開始

Test1.Xperia S 讀取Sony USB2.0 8G隨身碟讀取

這個組合當然可以正常被讀取成功，簡單讀取裡面的內容如下

Test2.Xperia S讀取ADATA USB3.0 32GB隨身碟

首先因為USB3.0的耗電量比較大，USB電力耗費錯誤的錯誤訊息，如下圖所示。

遇到這個問題要如何解決呢?其實你可以使用USB 2.0HUB就可以解決電力的問題，將USB3,0向下相容於2.0，這樣就可以將電力得到解決。

經過上面轉接，這樣就可以正常讀取到隨身碟裡面的資料了。

Test3.多台讀卡機測試
1.Transcend USB3.0讀卡機測試(記憶卡使用Transcend SDHC C10 32G、Transcend SDHC C10 16G、Sony SDHC C4 16G、TOSHIBA SDHC C6 16G)

測試結果失敗，均無法順利被讀取，他會出現USB儲存裝置已損壞。點選他可以進行格式化，但是格式化完成後還是無法使用。

2.ADR-18U2BL USB2.0 8in1讀卡機(記憶卡使用Transcend SDHC C10 32G、Transcend SDHC C10 16G、Sony SDHC C4 16G、TOSHIBA SDHC C6 16G)

測試結果依然失敗，錯誤訊息跟上面出現的相同

3.EasyATM口袋機晶片多合一讀卡機(USB2.0)(記憶卡使用Transcend SDHC C10 32G、Transcend SDHC C10 16G、Sony SDHC C4 16G、TOSHIBA SDHC C6 16G)

這台讀卡機終於可以被讀取到了

測試了三台讀卡機，目前只有這台可以正常被使用。

Test4.USB 2.0 2.5吋外接式隨身碟
使用這類型的隨身碟，最大的問題就是手機無法提供足夠的電量讓硬碟運作，所以要借助行動電源，並使用USB2.0電源線，讓USB HUB有足夠的電力。

畫面有點混亂，簡單來說接法語讀卡機相同，但唯一不同的地方就是增加了一條HUB電源線，並連接至行動電源上，而隨身碟必須使用雙頭USB接頭的線，將其中一條線插上HUB上，另外一端接到行動電源上面，這樣就可以順利被讀取到了。

Test5.於HUB上面接上多顆USB隨身碟，這次主要要測試如果用讀卡機，並接上USB隨身碟，在Xperia S上到底可不可以支援多顆外接裝置，如下圖所示。

結果無論怎麼測試，Xperia S只可以讀取到第一顆插上去的外接裝置，第二顆是無法被加入的，因此如果要進行備份的工作，必須將檔案複製到手機裡面，再由手機複製出來。

所以上述實驗主要想知道USB-OTG到底可不可以讓我不需要攜帶筆記型電腦出門呢?結論是可以的，但是無法同時支援多顆USB裝置，這樣要先複製到手機再複製出來有些麻煩，接下來做最後的測試，那就是Sony的平板電腦 Sony Tablet S 32G Wifi版。

Test6.Sony Tablet S USB-OTG測試，在這邊的測試我就不多做一一貼圖的動作了，簡單做個結論，Sony Tablet S 可以直接接上Usb 2,0的隨身碟，USB3,0也是可以，且不需透過USB HUB來進行向下相容，且上面所測試無法讀取的兩台讀卡機，在它上面卻都可以正常被讀取，最終我將所有USB隨身碟都給接上去，包含2.5吋隨身碟、USB3.0、USB 2.0隨身碟及讀卡機，如下圖所示。

結果出來了，證明Sony Tablet S可以讀取多個外接裝置，並且可以在這些外接裝置上進行複製等檔案操作。

做個小結論，Android手機或是平板電腦，只有有USB-OTG功能，簡單來講應該都支援外接的USB隨身碟裝置，而本次測試主要要了解這些外接的隨身碟或讀卡機要如何在此平台上正常運作，最終手機還是手機，它可以做最簡單的單一外接裝置讀取，如果真的要複製檔案，我覺得Sony Tablet S可以讓我們免去攜帶厚重的筆記型電腦出門的這個問題。

[Qt] - Creating a CUI application using Qt

2012-05-13T07:37:00.001-07:00

在第一篇教學中，已經簡單介紹如何使用QT如何建立一個簡單的OpenCV應用程式了，本範例將介紹如何使用QT GUI建立OpenCV應用程式。

Step1：

首先一樣開啟QT Creator軟體介面，如下圖所示，並點選Create Project按鈕。

Step2：

點選建立Qt C++ Project，並點選QT Gui Application，選取完畢之後點選choose，進行建立，如下圖所示。

Step3：建立專案

建立專案可以使用自己喜歡之名稱，並如下圖方式輸入。

補充說明:目前QT的資料管理方式為debug或是release資料夾必須與src平行，不得放於src資料夾當中，所以我們要建立一個資料夾，其中包含src、release、Debug。

Name： QT_GUI_opencv

Create in ：/home/trong/QT/QT_GUI_opencv

Src位於：/home/trong/QT/QT_GUI_opencv/QT_GUI_opencv

release資料夾：/home/trong/QT/QT_GUI_opencv/QT_GUI_opencv_release

debug資料夾：/home/trong/QT/QT_GUI_opencv/QT_GUI_opencv_debug

如下圖所示:

可自行輸入Class name及相關檔頭名稱

最後可管理該專案相關位置與設定，如下圖。

Step4：建立GUI介面

當建立好專案之後，其畫面如下圖所示，你可使用左手編織相關ui元件進行UI建立。

首先我們必須加入OpenCV相關include設定，方法與第一章相同，如下圖所示

CONFIG += link_pkgconfig
PKGCONFIG += opencv
INCLUDEPATH += /usr/local/opencv/include
LIBS += -L/usr/local/opencv/lib -lopencv_core -lopencv_imgproc -lopencv_highgui -lopencv_ml -lopencv_video -lopencv_features2d -lopencv_calib3d -lopencv_objdetect -lopencv_contrib -lopencv_legacy -lopencv_flann -lopencv_gpu

建立最簡單的方式PushButton按鈕，如下圖所示，可於PushButton中，拖拉的方式將PushButton拉至Dialog上，如下圖所示。

欲修改Button名稱，可點擊Button兩下，進入編輯畫面

編輯後畫面如下圖所示

每個PushButton均有一個ObjectName，你可透過下圖方式進行變更。

當編輯完畢之後你會發現在Mainwindow下之centralWidget中之兩個名稱也已經更改了。

接下來要加入按鍵點擊之動作，點選Button並點選右鍵開啟選單，並點選Go to slot進行程式碼編輯。

要新增點擊動作，請點選Clicked並點選OK進行新增。

開啟後畫面如下圖所示，你將可在Clicked()進行程式碼編輯，於該區域編輯之程式碼將於點即時開啟。

請再點選mainwindow.hpp進行Opencv加入，及相關函數設定，新增項目如下圖所示。

#ifndef MAINWINDOW_HPP
#define MAINWINDOW_HPP
#include <QMainWindow>
#include <QFileDialog>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
Ui::MainWindow *ui;
cv::Mat image;
private slots:
void on_Button_process_clicked();
void on_Button_Open_image_clicked();
};
#endif // MAINWINDOW_HPP

當加入Opencv相關hpp檔案之後，請再開啟mainwindow.cpp檔案，並於click按鈕屬性中加入下圖之程式碼。

QString fileName = QFileDialog::getOpenFileName(this,tr("Open Image"),".",tr("Image File (*.png *.jpge *.jpg *.bmp"));
image = cv::imread(fileName.toAscii().data());
cv::namedWindow("Original Image");
cv::imshow("Original Image", image);

再度加入Process按鈕動作。

其相關處裡程式碼如下圖所示。

cv::flip(image,image,1);
cv::namedWindow("Outout Image");
cv::imshow("Output Image",image);

當確認無誤之後將可進行編譯動作，請點選下圖Debug按鈕進行編譯。

Step5：測試專案

到此你可利用編譯完成之程式碼進行程式動作，程式介面如下圖所示，並點選Open Image開啟影像，定點選Process進行影像水平翻轉。

Step6：進階設計

QT GUI介面都依賴MainWindow進行執行，若我們需要在未開啟影像時，將Process按鈕進行禁止按下的動作時，我們可以在mainwindow.cpp中之MainWindow::MainWindow中加入下圖指令，並於Open image button加入指令，如下圖所示。

關閉按鈕
ui->Button_process->setEnabled(false);

開啟按鈕

ui->Button_process->setEnabled(true);

Step7：測試
再度進行編譯，並執行該編譯後的執行檔，在此可發現，若你尚未點選Open Image時，Process按鈕式反白的，此時無法點選。

再點選Open Image之後，Process按鈕恢復正常，可點選並執行所設計之指令。

Step8：將影像顯示在QT視窗上
下面範例要用到cv::cvtColor，這個函數，因此需要再mainwindow.hpp中加入"#include <opencv2/opencv.hpp>"。QImage可以顯示在TexeLabel上面，因此我們先利用拖拉的方式將TextLbel新增至Dialog當中，如下圖所示。

並可點選TexeLabel兩下，進行編輯文字，這邊要顯示影像，因此將文字給刪除。

新增顯示於Label之方法，請開啟mainwindow.cpp檔案，並在Button_Process_clicked()函數中加入下列程式碼。
cv::cvtColor(image,image,CV_BGR2RGB);
QImage img=QImage((const unsigned char*)(image.data),//Qtimagestructure
image.cols,image.rows,QImage::Format_RGB888);
ui->label->setPixmap(QPixmap::fromImage(img));//displayonlabel
ui->label->resize(ui->label->pixmap()->size());//resizethelabeltofittheimage
Step9：進行測試
相同你可以點選Open Image進行檔案開啟動作，並點選Process按鈕進行影像水平旋轉及顯示於QT視窗當中，其結果如下所示。

進階應用：Function

在我們已經成功將影像呼叫出來，並且使用opencv進行影像處理之後，我們都要透過QImage的方式，將影像再度轉換回QT上面做顯示，這邊我們可以寫一個小小的class來管理這個轉換，讓我們有其他程式也想使用該class時，不需要再度寫一次相同的程式。首先我們開啟mainwindow.hpp檔案，並加入

void UpdateQImage(const cv::Mat &cvimg);

也就是說我們建立一個UpdateQImage的一個class，其中要放入的函數類型為"const cv::Mat &cvimg"，如下圖所示。

再回到mainwindow.cpp檔案加入"void MainWindow::UpdateQImage(const cv::Mat &cvimg)"程式，如下圖所示。

相關程式碼如下:

// Convert OpenCV image to QImage.
void MainWindow::UpdateQImage(const cv::Mat &cvimg){
    QImage qimg=QImage((const unsigned char*)(cvimg.data),
                 cvimg.cols,cvimg.rows,QImage::Format_RGB888);
    ui->label->setPixmap(QPixmap::fromImage(qimg));
    ui->label->resize(ui->label->pixmap()->size());
}

並將"void MainWindow::on_Button_process_clicked()"中之程式修改成

void MainWindow::on_Button_process_clicked()
{

    cv::flip(image,image,1);
    cv::cvtColor(image,image,CV_BGR2RGB);
    UpdateQImage(image);
}

如此一來，只要你點選Process按鈕將會去執行filp動作，並將結果傳回UpdateQImage函數中進行顯示。

私有變數使用

上面幾個小程式中，其實我們已經使用了非常多變數了，這些變數如果你只是呼叫一次，那每次都進行宣告是無所謂的，但是如果該變數要使用非常多次呢?每次都要開一個變數來存放他嗎?

其實上半部，步驟三我們就已經有定義了一個私有變數"cv::Mat image;"我們將它放在"private:"當中，定義image為cv::Mat類別之變數，這樣你只要在這個程式中使用image，你就可以去使用這個變數了。這邊簡單來說如果我們要去處理一張影像，當每次處理完之後都要再去開一個變數來存放他，這樣有再大的記憶體也不構放，因此我們在定義一個cv::Mat類別的變數，用來承接我們運算後的影像結果，請開啟檔案"mainwindow.h"，並於private:加入變數cv::Mat result;，如下圖所示。

加入之後，將可進行Open image button的動作修改，請開啟檔案"mainwindow.cpp"，修改function"on_Button_Open_image_clicked()"，將result等於原本讀取完畢的image，並利用UpdateQImage(result);來更新顯示視窗。如下圖所示。

那接下來要去修改

並將Button Process click指令中修改成result=IPtool.flip(result,1);，這樣的方式，以後如果有其他的影像處理方式，就可以直接沿用這個架構去執行。

本次OpenCV所使用的相關函數

Mat

class Mat

OpenCV C++ n-dimensional dense array class

class CV_EXPORTS Mat

{

public:

// ... a lot of methods ...

...

/*! includes several bit-fields:

- the magic signature

- continuity flag

- depth

- number of channels

*/

int flags;

//! the array dimensionality, >= 2

int dims;

//! the number of rows and columns or (-1, -1) when the array has more than 2 dimensions

int rows, cols;

//! pointer to the data

uchar* data;

//! pointer to the reference counter;

// when array points to user-allocated data, the pointer is NULL

int* refcount;

// other members

...

};

cvtColor

Converts an image from one color space to another.

C++: void cvtColor(InputArray src, OutputArray  dst, int code , int dstCn=0 )

Python:  cv2. cvtColor(src, code[ , dst[, dstCn ] ]) → dst

C: void cvCvtColor(const CvArr* src, CvArr* dst, int code )

Python:  cv. CvtColor(src, dst, code) → None

Parameters

src – Source image: 8-bit unsigned, 16-bit unsigned ( CV^_16UC...  ), or single-precision floating-point.

dst – Destination image of the same size and depth as src .

code – Color space conversion code. See the description below.

dstCn – Number of channels in the destination image. If the parameter is 0, the number of the channels is derived automatically from src and code .

The function converts an input image from one color space to another. In case of a transformation to-from RGB color space, the order of the channels should be specified explicitly (RGB or BGR). Note that the default color format in OpenCV is often referred to as RGB but it is actually BGR (the bytes are reversed). So the first byte in a standard (24-bit) color image will be an 8-bit Blue component, the second byte will be Green, and the third byte will be Red. The fourth, fifth, and sixth bytes would then be the second pixel (Blue, then Green, then Red), and so on.

The conventional ranges for R, G, and B channel values are:

• 0 to 255 for CV ^_8U images

• 0 to 65535 for CV ^_16U images

• 0 to 1 for CV ^_32F images

In case of linear transformations, the range does not matter. But in case of a non-linear transformation, an input RGB image should be normalized to the proper value range to get the correct results, for example, for RGB → L*u*v* transformation. For example, if you have a 32-bit floating-point image directly converted from an 8-bit image without any scaling, then it will have the 0..255 value range instead of 0..1 assumed by the function. So, before calling cvtColor , you need first to scale the image down:

img  _* =  1. /255 ;

_{cvtColor(img, img, CV} ^__BGR2Luv);

If you use cvtColor with 8-bit images, the conversion will have some information lost. For many applications, this will not be noticeable but it is recommended to use 32-bit images in applications that need the full range of colors or that convert an image before an operation and then convert back.

The function can do the following transformations:

QT使用指令
QFileDialog Class

The QFileDialog class provides a dialog that allow users to select files or directories. More...
 #include <QFileDialog>
Static Public Members

QString getExistingDirectory(QWidget * parent = 0, const QString & caption = QString(), const QString & dir = QString(), Optionsoptions = ShowDirsOnly)

QString getOpenFileName(QWidget * parent = 0, const QString & caption = QString(), const QString & dir = QString(), const QString &filter = QString(), QString * selectedFilter = 0, Options options = 0)

QStringList getOpenFileNames(QWidget * parent = 0, const QString & caption = QString(), const QString & dir = QString(), const QString &filter = QString(), QString * selectedFilter = 0, Options options = 0)

QString getSaveFileName(QWidget * parent = 0, const QString & caption = QString(), const QString & dir = QString(), const QString &filter = QString(), QString * selectedFilter = 0, Options options = 0)

example
 fileName = QFileDialog::getOpenFileName(this,
     tr("Open Image"), "/home/jana", tr("Image Files (*.png *.jpg *.bmp)"));
If you want to use multiple filters, separate each one with two semicolons. For example:
 "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
http://qt-project.org/doc/qt-5.0/qfiledialog.html

[Qt]Creating a OpenCV 2.3.1 application using QT

2012-05-12T07:27:00.000-07:00

Creating a OpenCV 2.3.1 application using QT

1.本次環境選用 Ubuntu 10.10、OpenCV 2.3.1 、cuda 4.0、QT 4.6

首先開啟QT介面

2.利用QT開啟新專案

File->New File or Project

3.建立QT Console Application

在新建視窗中點選QT C++ Project，再點選建立QT Console Application

4.建立專案名稱及存放路徑

在這裡建議建立下面三個資料夾

/home/trong/QT/QT_opencv_test/

/home/trong/QT/QT_opencv_test/QT_opencv_release

/home/trong/QT/QT_opencv_test/QT_openccv_debug

並將上面位置修改成

Name: QT_opencv_test

Create in: /home/trong/QT/QT_opencv_test

5.專案設置部分在此先不設立，直接點選Finish完成

6.在QT中設置開發環境

當建立專案檔之後，其環境設定檔將為"檔名.pro"檔案，你必須要此設立相關include路徑，及lib路徑等，在opencv教學文件中提到，只要設輸入下列兩行，將可自動呼叫系統變數，並將需要使用之函數加入，但不知該版本的問題還是哪邊設定出了錯，依然無法使用該方式加入，因此只好手動將需要之include路徑及lib路徑輸入，如下圖所示。

CONFIG += link_pkgconfig

PKGCONFIG += opencv

上述設定如下表所示

CONFIG += link_pkgconfig
PKGCONFIG += opencv
INCLUDEPATH += /usr/local/opencv/include
LIBS += -L/usr/local/opencv/lib -lopencv_core -lopencv_imgproc -lopencv_highgui -lopencv_ml -lopencv_video -lopencv_features2d -lopencv_calib3d -lopencv_objdetect -lopencv_contrib -lopencv_legacy -lopencv_flann -lopencv_gpu

7.利用Opencv 讀取影像開啟影像之動作

上述程式碼如下表

#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>

#include <iostream>

int main()
{

// read an image
cv::Mat image= cv::imread("beach.jpg");
// create image window named "My Image"
cv::namedWindow("My Image");
// show the image on window
cv::imshow("My Image", image);
// wait key for 5000 ms
cv::Mat result;
cv::flip(image,result,1);

cv::namedWindow("result image");
cv::imshow("result image",result);

cv::waitKey(5000);

return 1;
}

8.在QT中建立Build資料夾

QT中你必須設定一個Build的資料夾，這個資料夾位置不可與專案檔在一起，因此自行建立一個資料夾供該Build使用

Build directory

Release：/home/trong/QT/QT_opencv_test/QT_opencv_release

Debug：/home/trong/QT/QT_opencv_test/QT_openccv_debug

9.Build C++ 程式

當編寫好程式碼之後發現無任何錯誤，可使用下圖進行Build動作

建立好的檔案如下圖所示

10.執行該程式

你可以直接點選該執行檔進行檔案執行，執行結果如下圖所示

11.本次OpenCV所使用的相關函數

imread

Loads an image from a file.

C++: Mat imread(const string&  filename, int flags=1 )

Python:  cv2.imread(filename[, flags ]) → retval

C: IplImage* cvLoadImage(const char* filename, int flags=CV_LOAD_IMAGE_COLOR ) C: CvMat* cvLoadImageM(const char* filename, int flags=CV_LOAD_IMAGE_COLOR ) Python:  cv.LoadImage(filename, flags=CV_LOAD_IMAGE_COLOR) → None

Python:  cv.LoadImageM(filename, flags=CV_LOAD_IMAGE_COLOR) → None

Parameters

filename – Name of file to be loaded.

flags – Flags specifying the color type of a loaded image:

– >0 Return a 3-channel color image

– =0 Return a grayscale image

– <0 Return the loaded image as is. Note that in the current implementation the alpha channel, if any, is stripped from the output image. For example, a 4-channel RGBA image is loaded as RGB if flags ≥ 0 .

The function imread loads an image from the specified file and returns it.   If the image cannot be read (be- cause of missing file, improper permissions, unsupported or invalid format), the function returns an empty matrix ( Mat::data==NULL ). Currently, the following file formats are supported:

• Windows bitmaps - _*.bmp,  _*.dib (always supported)

• JPEG files - _*.jpeg, _*.jpg, _*.jpe (see the Notes section)

• JPEG 2000 files - _*.jp2 (see the Notes section)

• Portable Network Graphics - _*.png (see the Notes section)

• Portable image format - _*.pbm,  _*.pgm,  _*.ppm (always supported)

• Sun rasters - _*.sr,  _*.ras (always supported)

• TIFF files - _*.tiff,  _*.tif (see the Notes section)

Note:

• The function determines the type of an image by the content, not by the file extension.

• On Microsoft Windows* OS and MacOSX*, the codecs shipped with an OpenCV image (libjpeg, libpng, libtiff, and libjasper) are used by default. So, OpenCV can always read JPEGs, PNGs, and TIFFs. On MacOSX, there is also an option to use native MacOSX image readers. But beware that currently these native image loaders give images with different pixel values because of the color management embedded into MacOSX.

• On Linux*, BSD flavors and other Unix-like open-source operating systems, OpenCV looks for codecs supplied with an OS image. Install the relevant packages (do not forget the development files, for example, “libjpeg-dev”, in Debian* and Ubuntu*) to get the codec support or turn on the OPENCV^_BUILD^_3RDPARTY^_LIBS flag in CMake.

namedWindow

Creates a window.

C++: void namedWindow(const string& winname, int flags)

Python:  cv2.namedWindow(winname[, flags ]) → None

C: int cvNamedWindow(const char* name, int flags)

Python:  cv.NamedWindow(name, flags=CV_WINDOW_AUTOSIZE) → None

Parameters

name – Name of the window in the window caption that may be used as a window identifier.

flags – Flags of the window. Currently the only supported flag is CV^_WINDOW^_AUTOSIZE

. If this is set, the window size is automatically adjusted to fit the displayed image (see

imshow() ), and you cannot change the window size manually.

The function namedWindow creates a window that can be used as a placeholder for images and trackbars. Created windows are referred to by their names.

If a window with the same name already exists, the function does nothing.

You can call destroyWindow() or destroyAllWindows() to close the window and de-allocate any associated mem- ory usage. For a simple program, you do not really have to call these functions because all the resources and windows of the application are closed automatically by the operating system upon exit.

Note: Qt backend supports additional flags:

• CV_WINDOW_NORMAL or CV_WINDOW_AUTOSIZE: CV^_WINDOW^_NORMAL enables you to resize the window, whereas CV^_WINDOW^_AUTOSIZE  adjusts automatically the window size to fit the displayed image (see imshow() ), and you cannot change the window size manually.

• CV_WINDOW_FREERATIO or CV_WINDOW_KEEPRATIO: CV^_WINDOW^_FREERATIO  adjusts the image with no respect to its ratio, whereas CV^_WINDOW^_KEEPRATIO  keeps the image ratio.

• CV_GUI_NORMAL or CV_GUI_EXPANDED: CV^_GUI^_NORMAL is the old way to draw the window without statusbar and toolbar, whereas CV^_GUI^_EXPANDED is a new enhanced GUI.

By default, flags == CV^_WINDOW^_AUTOSIZE | CV^_WINDOW^_KEEPRATIO | CV^_GUI^_EXPANDED

imshow

Displays an image in the specified window.

C++: void imshow(const string& winname, InputArray image)

Python:  cv2.imshow(winname, image) → None

C: void cvShowImage(const char* winname, const CvArr* image)

Python:  cv.ShowImage(winname, image) → None

Parameters

winname – Name of the window.

image – Image to be shown.

The function imshow   displays an image in the specified window.    If the window was created with the CV^_WINDOW^_AUTOSIZE flag, the image is shown with its original size. Otherwise, the image is scaled to fit the window. The function may scale the image, depending on its depth:

• If the image is 8-bit unsigned, it is displayed as is.

• If the image is 16-bit unsigned or 32-bit integer, the pixels are divided by 256. That is, the value range

[0,255*256] is mapped to [0,255].

• If the image is 32-bit floating-point, the pixel values are multiplied by 255. That is, the value range [0,1] is

mapped to [0,255].

waitKey

Waits for a pressed key.

C++: int waitKey(int delay=0)

Python:  cv2.waitKey([delay ]) → retval

C: int cvWaitKey(int delay=0 )

Python:  cv.WaitKey(delay=0) → int

Parameters

delay – Delay in milliseconds. 0 is the special value that means “forever”.

The function waitKey waits for a key event infinitely (when delay ≤ 0 ) or for delay milliseconds, when it is positive. Since the OS has a minimum time between switching threads, the function will not wait exactly delay ms, it will wait at least delay ms, depending on what else is running on your computer at that time. It returns the code of the pressed key or -1 if no key was pressed before the specified time had elapsed.

the pressed key or -1 if no key was pressed before the specified time had elapsed.

Note:   This function is the only method in HighGUI that can fetch and handle events, so it needs to be called

periodically for normal event processing unless HighGUI is used within an environment that takes care of event processing.

Note: The function only works if there is at least one HighGUI window created and the window is active. If there are

several HighGUI windows, any of them can be active.

flip

Flips a 2D array around vertical, horizontal, or both axes.

C++: void flip(InputArray src, OutputArray  dst, int flipCode)

Python:  cv2.flip(src, flipCode[, dst ]) → dst

C: void cvFlip(const CvArr* src, CvArr* dst=NULL, int flipMode=0)

Python:  cv.Flip(src, dst=None, flipMode=0) → None

Parameters

src – Source array.

dst – Destination array of the same size and type as src .

flipCode – Flag to specify how to flip the array. 0 means flipping around the x-axis. Positive value (for example, 1) means flipping around y-axis. Negative value (for example, -1) means flipping around both axes. See the discussion below for the formulas.

The function flip flips the array in one of three different ways (row and column indices are 0-based):

The example scenarios of using the function are the following:

• Vertical flipping of the image (flipCode == 0) to switch between top-left and bottom-left image origin. This is a typical operation in video processing on Microsoft Windows* OS.

• Horizontal flipping of the image with the subsequent horizontal shift and absolute difference calculation to check for a vertical-axis symmetry (flipCode > 0).

• Simultaneous horizontal and vertical flipping of the image with the subsequent shift and absolute difference calculation to check for a central symmetry (flipCode < 0).

• Reversing the order of point arrays (flipCode > 0 or flipCode == 0).

See Also:

transpose() , repeat() , completeSymm()

How to install CUDA 4.0 12.2 on Ubuntu 10.10

2012-05-07T08:01:00.002-07:00

目前測試Ubuntu 10.10版本安裝CUAD，其主要原因是OpenCV 2.3.1所使用的CUDA toolkit版本為4.0.17，而nvidia所以提供的Cuda toolkit 4.0.17版本號僅支援ububtu 10.10，因此先拿10.10做測試，如果測試OK未來將使用11.10版本進行測試安裝

Step1.首先安裝ubuntu

注意:OpenCV_2.3.1使用的CUDA Toolkit 為CUDA 4.0版本，所以ToolKit 與SDK版本均要下載4.0版本，不然Make將會出錯
下載檔案如下
NVIDIA-Linux-x86_64-285.05.33.run
cudatoolkit_4.0.17_linux_64_ubuntu10.10.run
gpucomputingsdk_4.0.17_linux.run

Step2.安裝Cuda

a.安裝CUDA時須先離開xwindow,

ubuntu 10.10離開方式

#sudo stop gdm
ubuntu 11.04離開方式

#sudo stop lightdm

b.安裝Nvidia 驅動程式

#sudo ./NVIDIA-Linux-x86_64-285.05.33.run
c.安裝Nvidia Cuda toolkit 4.0

#sudo cudatoolkit_4.0.17_linux_64_ubuntu10.10.run

非常注意，這邊使用的OpenCV2.3.1一定要對應Toolkit 4.0版本

d.安裝CUDA SDK 4.0

#sudo gpucomputingsdk_4.0.17_linux.run
e.設定相關系統path

#sudo vi /etc/bash.bashrc

於最下面加入

export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/cuda/lib:$LD_LIBRARY_PATH

# The following line should on the last line of this file.
export PATH=.:$PATH

f.安裝編譯相關程式

#sudo apt-get install build-essential gcc-4.4 g++-4.4 libxi-dev libxmu-dev freeglut3-dev
g.將SDK進行編譯測試

預設SDK安裝於'/home/user/NVIDIA_GPU_Computing_SDK'資料夾當中，user為你的使用者名稱。

#cd NVIDIA_GPU_Computing_SDK/C/

#make

若編譯過程中無出現任何錯誤，將可編譯出下列執行檔。

測試編譯的執行檔。

#./deviceQuery

若出現下列訊息，表示該平台可以正常運作CUDA

Step3.安裝OpenCV 2.3.1

至官方網站下載OpenCV tar套件OpenCV-2.3.1a.tar.bz2

Step a.安裝相關有用之lib庫

#sudo apt-get install cmake-gui libjpeg62 libjpeg62-dev libgtk2.0-0 libgtk2.0-dev libjpeg62-dev libtiff4-dev libjasper-dev libopenexr-dev cmake python-dev python-numpy libtbb-dev libeigen2-dev yasm libfaac-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev libtbb-dev

Step b.安裝OpenCV

建立opencv安裝目錄

#mkdir /usr/local/opencv2.3.1

#ln -s /usr/local/opencv2.3.1 /usr/local/opencv

Symbolic Link (符號連結，亦即是捷徑)相對於 hard link ， Symbolic link 可就好理解多了，基本上， Symbolic link 就是在建立一個獨立的檔案，而這個檔案會讓資料的讀取指向他 link 的那個檔案的檔名！由於只是利用檔案來做為指向的動作，所以，當來源檔被刪除之後，symbolic link 的檔案會『開不了』，會一直說『無法開啟某檔案！』。實際上就是找不到原始『檔名』而已啦！
ln指令：連結檔案或目錄
語法:ln -[可選參數] 原始檔案/目錄目的檔案/目錄

參數說明：

不加：預設值；只限於相同檔案系統間的連結，且不能連結目錄

s：可作不同檔案系統間的連結，且能連結目錄

f：如果要連結成的檔案已存在，則砍掉這個已存在的檔案

n：如果要連結成的檔案已存在，則停止連結，不會砍掉該檔案

上述動作於/usr/local/資料夾中建立opencv資料夾，在將opencv2.3.1指向 opencv資料夾，可以有效管理安裝的資料夾，若需更改其他版本，請直接指向另外一個版本之資料夾，將可以不需更改PATH資料夾。

Step c.使用cmake-gui 建立 makefile

#cd ~/opencv_2.3.1/

#mkdir release

#cd release/

#cmake-gui ../

CMAKE_BUILD_TYPE=RELEASE

CMAKE_INSTALL_PREFIX=/usr/local/opencv

WITH_CUDA=1

點選configure進行設定,這邊我們先手動啟動一些設定值，還有安裝的目錄很重要。
使用預設的compilers進行編譯
當點選Finish 之後會進行初步設定，此時有一個值要手動建立Path for CUDA_SDK_ROOT_DIR，請用瀏覽的方式，將該設定值設定為你所安裝SDK的位置，如下圖所示。
再度點選Configure若無出現錯誤，將可點選Generate進行建立該MakeFile檔案
#make
若安裝過程中無出現錯誤，代表所有設定值與安裝之lib未出現錯誤，此時將可進行install動作
#sudo make install
注意:
cmake-gui中設定opencv安裝目錄"CMAKE_INSTALL_PREFIX=/usr/local/opencv"，若make install後發現並無安裝置/usr/local/opencv中，可檢查MakeFile.cmake檔案，並修改INSTALL_PRFIX路徑位置

#gedit cmake_install.cmake
修改CMAKE_INSTALL_PREFIX="/use/local" 為 "/usr/local/opencv"

修改設定檔
因為安裝路徑有修改，所以prefix=/usr/local將改成/usr/local/opencv

並加-lopencv_gpu加入引用程式庫。
Step d. 修改系統變數

#sudo gedit /etc/bash.bashrc

加入下列紅色字串。

export PATH=/usr/local/cuda/bin:/usr/local/opencv/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/cuda/lib:/usr/local/opencv/lib:$LD_LIBRARY_PATH

export PKG_CONFIG_PATH=/usr/local/opencv/lib/pkgconfig:${PKG_CONFIG_PATH}

# The following line should on the last line of this file.
export PATH=.:$PATH

Step e. 加入動態連結管理員

請於/etc/ld.so.conf.d/資料夾當中新增opencv.conf檔案，檔案內容

/usr/local/opencv/lib

新增後重新啟動ldconfig即可

#sudo ldconfig

Step4. OpenCV 2.3.1 with CUDA test

a.建立簡單應用gpu開啟影像並做基本處裡，原始碼如下圖所示，檔名為main.cpp。

#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/gpu/gpu.hpp>

int main (int argc, char* argv[])
{
    try
    {
          int num_device=cv::gpu::getCudaEnabledDeviceCount();
          std::cout<< "Number of GPU device " << num_device<<std::endl;

        cv::Mat src_host = cv::imread("beach.jpg",CV_LOAD_IMAGE_GRAYSCALE);

        cv::gpu::GpuMat dst, src;
        src.upload(src_host);

        cv::gpu::threshold(src, dst, 128.0, 255.0, CV_THRESH_BINARY);

        cv::Mat result_host = dst;
        cv::imshow("Result", result_host);
        cv::waitKey();
    }
    catch(const cv::Exception& ex)
    {
        std::cout << "Error: " << ex.what() << std::endl;
    }
    return 0;
}

編譯c++

#g++ main.cpp -o gpu_test `pkg-config --cflags --libs opencv`

執行如下圖所示。

b.GPU Device info

#include <opencv2/opencv.hpp>
#include <opencv2/gpu/gpu.hpp>
#include <iostream>

int main() {
     int num_device= cv::gpu::getCudaEnabledDeviceCount();
     std::cout << "Number of CUDA device: " << num_device << std::endl;
     if (num_device>0) {
          int dev_id=cv::gpu::getDevice();
          cv::gpu::DeviceInfo dev_info;

          dev_info=cv::gpu::DeviceInfo::DeviceInfo(dev_id);
          std::cout << "Device information" << std::endl;
          std::cout << "Device name: " << dev_info.name() << std::endl;
          std::cout << "Number of Processor: " << dev_info.multiProcessorCount() << std::endl;
          std::cout << "Total Memory: " << dev_info.totalMemory()/1024 << " (Mb)" << std::endl;
     }
     return 0;
}

OpenCV 2.3.1 with Visual Studio 2010

2012-05-06T09:11:00.001-07:00

雖然OpenCV 2.4已經正式釋出了，這邊還是先做2.3.1的介紹，安裝步驟如下。

Step1.下載OpenCV-2.3.1-win-superpack.exe

Step2.將下載之Superpack進行解壓縮

該解壓縮位置非常重要，是接下來path等相關環境變數所要設定的位置。本範例解壓縮至"C:\OpenCV_2.3.1\"

Step3.設定Window 環境變數

a.新增系統變數OPENCV_DIR=C:\OpenCV_2.3.1

b.查看是否有新增成功

c.修改Path環境變數，

加入OpenCV bin位置"%OPENCV_DIR%\build\x64\vc10\bin"

補充:

如果要加入GPU計算(CUDA)，PATH路徑%OPENCV_DIR%\build\gpu\x64\bin，兩個不可以同時加入，因為bin裡面的資料都相同，系統將無法判別要使用哪個dll檔案。

加入TBB bin 位置"%OPENCV_DIR%\build\common\tbb\intel64\vc10"

d.查看是否新增成功

Step4: Visual Studio 2010 設置屬性

a.於Visual Studio 2010中，新增win32主控台應用程式

b.Win32應用程式精靈

點選建立空專案並且點選完成。

c.建立x64應用程式專案

這次的目標是要建立x64版本的OpenCV程式，如下圖所示點選組態管理員

於平台選單中點選新增

並新增新平台為x64

新增後組態管理員將出現Debug | x64 與 Release | x64專案屬性

若無需建立Win32版本，可由此案右鍵將組態給移除。

於此可用Visual Studio 2010之新功能，先建立專案屬性，利用該專案屬性功能先建立預設值，未來將可直接在入該檔案，無須每次進行下列設定。於Debug | x64 按右鍵，並點選加入新的專案屬性工作表。如下圖所示。

建立該屬性名稱，輸入名稱OpenCVProject，並點選新增。

建立屬性工作表之後，請於屬性工作表裏面進行編輯，點選OpenCVProject兩下開啟OpenCVProject屬性。

加入OpenCV Include目錄。

加入"$(OPENCV_DIR)\build\include"

注意$(OPENCV_DIR)為windows環境變數，於Step3.時加入，相對應資料夾為C:\OpenCV_2.3.1

加入程式庫目錄"$(OPENCV_DIR)\build\x86\vc10\lib"

補充

如果使用的是GPU加速版本，要將lib庫指向 $(OPENCV_DIR)\build\gpu\x64\lib

修改後如下

新增上述兩個目錄之後將OpenCVProject儲存，如下圖所示。

Release項將可直接加入該屬性工作表即可。

最後要新增C++裡面的其他相依性，於Debug | x64 上點選右鍵"屬性"，並於"輸入"之其他相依性加入OpenCV之lib檔案

Release | x64也須做相同的動作，下面列出相關lib輸入值，該相依性可依據該專案進行新增，若該專案用不到該lib將可不需填入。

如何使用DOS指令將所有lib進行List

DOS指令
Release列表
dir/b *231.lib > release_list.txt
Debug列表
dir/b *231d.lib > debug_list.txt

輸出結果
release
opencv_calib3d231.lib
opencv_contrib231.lib
opencv_core231.lib
opencv_features2d231.lib
opencv_flann231.lib
opencv_gpu231.lib
opencv_highgui231.lib
opencv_imgproc231.lib
opencv_legacy231.lib
opencv_ml231.lib
opencv_objdetect231.lib
opencv_ts231.lib
opencv_video231.lib

debug
opencv_calib3d231d.lib
opencv_contrib231d.lib
opencv_core231d.lib
opencv_features2d231d.lib
opencv_flann231d.lib
opencv_gpu231d.lib
opencv_highgui231d.lib
opencv_imgproc231d.lib
opencv_legacy231d.lib
opencv_ml231d.lib
opencv_objdetect231d.lib
opencv_ts231d.lib
opencv_video231d.lib

Debug
opencv_core231d.lib
opencv_imgproc231d.lib
opencv_highgui231d.lib
opencv_ml231d.lib
opencv_video231d.lib
opencv_features2d231d.lib
opencv_calib3d231d.lib
opencv_objdetect231d.lib
opencv_contrib231d.lib
opencv_legacy231d.lib
opencv_flann231d.lib

Release
opencv_core231.lib
opencv_imgproc231.lib
opencv_highgui231.lib
opencv_ml231.lib
opencv_video231.lib
opencv_features2d231.lib
opencv_calib3d231.lib
opencv_objdetect231.lib
opencv_contrib231.lib
opencv_legacy231.lib
opencv_flann231.lib

Step5: OpenCV Hello World

建立簡單OpenCV顯示圖片程式

於原始程式檔中加入一新增項目。如下圖所示。

新增C++檔案，檔名為main.cpp

貼上測試程式碼。

如何驗證你所建立的專案與OpenCV lib有成功連結，你可以簡單輸入cv::，如果有出現下圖相關程式，代表該專案已經成功與OpenCV連結。

測試專案是否可以常運作

如果出現下圖，無任何錯誤發生，代表該執行檔已經成功被Compiled

成功Compil出一個OpenCV程式了。

Step5: OpenCV whith cuda Hello World

上述安裝步驟中如果你需要啟動CUDA平行運算，可以參考補充部分，將path及Lib dll庫的位置設定為GPU用，這樣您將可以使用OpenCV上的CUDA運算。

回顧:

1.環境變數修改成:%OPENCV_DIR%\build\gpu\x64\bin

2.Visual Studio 2010中C++ lib 庫路徑指向 $(OPENCV_DIR)\build\gpu\x64\lib

3.OpenCV with 需要硬體與驅動程式部分

a.支援CUDA平行運算之NVIDIA顯示卡

b.安裝nvidia驅動程式。4.0以上，版範例安裝 devdriver_4.1_winvista-win7_64_286.19_general.exe

c.安裝CUDA ToolKit。OpenCV 2.3.1 Release 時所使用的版本為4.0.17 所以要安裝 cudatoolkit_4.0.17_win_64.msi，若已經安裝cudatoolkit_4.1.28_win_64.msi，可在下載安裝4.0.17版即可，ToolKit可以共存不同版本，因此不須將新舊版本進行移除。

d.安裝CUDA SDK 。本範例安裝 gpucomputingsdk_4.1.28_win_64.exe。

4.OpenCV 2.3.1 With CUDA Test

使用OpenCV所提供的範例如下。

輸出結果，範例中顯示本電腦有一個GPU device，並且可以使用他進行編譯及執行。

文章測試

2012-05-06T08:04:00.002-07:00

很久沒有建立自己的網誌了，這個小地方，分享一些程式設計的點點滴滴，希望你會喜歡。

Label	Object	ObjectName
	QTextEdit	displayTextEdit
Color	QPushButton	color_B
Message	QPushButton	Message_B
File	QPushButton	File_B
Font	QPushButton	Font_B
Input	QPushButton	Input_B
Page Setup	QPushButton	PageSetup_B
Progress	QPushButton	Progress_B
Print	QPushButton	Print_B

ui物件	objectName	label
1.TexeLabel	label	Cell Location:
2.Line Edit	lineEdit
3. Horizontal Spacer
4.pushButton	okButton	OK
5.pushButton	cancelButton	Cancel