Windows 8.1 + Update Window 10

Ieri sera mi sono finalmente deciso a fare l’update del mio sistema operativo Windows 8.1 verso Window 10 come dal 29 Luglio Microsoft mi pressava assai :D.

Ovviamente non l’ho fatto subito perchè ho acquistato un HD di backup. Fatto il mio solito BackUp con Paragon Migrate OS to SSD 4.0 (infallibile!) ho messo il nuovo disco sul PC e ho lanciato l’upgrade.

Per fare il tutto Windows ha impiegato 3 ore…

IMG_1415

 

… ero già pronto al peggio e invece…

Tutto è andato perfettamente. Tutti i driver sono stati installati correttamente

gestione_dispositivi

e tutti i programmi che utilizzo più spesso non hanno dato problemi (…fino ad ora… 😀 )

Anzi, anche i driver invidia che stranamente avevano smesso di funzionare (tutti i nuovi installer davano BSOD in fase di installazione) hanno ripreso ad andare.

context_memu

Direi che fino ad ora sono più che soddisfatto dell’Upgrade.

Il mio PC è un HP Envy 17-j111sl.

Questa volta devo dire… brava Microsoft!

 

Windows 8.1 + Update Window 10

OpenCV 3.0 + openCL + First call overhead

Se siete in transizione verso le OpenCV 3.0 vi consiglio di leggere questo post:

http://answers.opencv.org/question/67592/opencv-30-vs-opencv-249-sobel-performance/

In cui anche non volendo utilizzare OpenCL se non lo setto forzatamente a “false” ho un overhead nella prima chiamata delle funzioni di image processing.

Oltre ovviamente alla guida ufficiale:

http://docs.opencv.org/master/db/dfa/tutorial_transition_guide.html

Riporto qui di seguito la citazione nel caso qualcuno chiudesso il post:

In relation to the first call overhead can you test if it helps if you add the following in your code

#include <opencv2/core/ocl.hpp>

and then

cv::ocl::setUseOpenCL(false);

at the begining.

Yes I know that you are using cv::Mat and not cv::UMat, but I observed a similar behavior in my Code even if I use cv::Mat.

By the way, another solution might be to disable the OpenCL dynamic loader by building OpenCV with

cmake -DHAVE_OPENCL_STATIC=ON -DOPENCL_LIBRARY=... -DOPENCL_INCLUDE_DIR=....

This will ensure that OpenCL is only called if you explicitly call and OpenCL function from the ocl class.

 

OpenCV 3.0 + openCL + First call overhead

Compilare le OpenCV 3.0 con CUDA 7 e VisualStudio 2013 per x64

OpenCV 3.0

Occi vi mostrerò come compilare le OpenCV con il supporto per le schede grafiche NVIDIA.

Prima di tutto scarichiamo le OpenCV 3.0 dal loro repository su GitHub: https://github.com/Itseez/opencv.

Installiamo i sorgenti dove più ci piace, per questo esempio io le metterò sul Desktop.

Poi scarichiamo CMake che al momento della stesura di questo articolo è alla versione 3.3.0. Installiamolo. Io ho utilizzato il Win32 Installer.

Scarichiamo ovviamente il CUDA toolkit dal sito della NVIDIA e installiamolo. Al momento di stesura dell’articolo siamo alla versione 7.0. Io ho installato il Windows 8.1 local installer.

Lanciamo CMake e andiamo a dare il percorso dei sorgenti delle OpenCV e della cartella dove vogliamo generare la solution di Visual Studio 2013 per la compilazione:

cmake

 

 

Spuntare “Grouped” e “Advanced”, cliccare su “Configure” e scegliere “Visual Studio 12 2013 Win64” e poi “Finished” e aspettare il termine.

cmake2

Al termine dovremmo vedere “configure done” scritto nella finestra di console di CMake ma la parte centrale probabilmente verrà evidenziata di rosso:

cmake3

 

Espandiamo il nodo BUILD nella finestra rossa ed eliminiamo la spunta da BUILD_DOCS.

Nel mio caso l’errore deo Config era il fatto che non trova Doxygen. Semplicemente così dovremmo risolvere il conflitto.

Però io ho eliminato anche la generazione degli esempi per velocizzare un po’ la compilazione togliendo la spunta da BUILD_EXAMPLES

cmake_build

Controlliamo che nel nodo CMAKE il valore di CMAKE_LINKER sia il linker di Visual Studio 2013 (v12).

cmake_linker

Controlliamo che nel nodo CUDA non sia selezionato (eventualmente togliamo la sputa da) CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE.

Questo flag server se si eseguono Build in parallelo.

cmake_cuda

Nel nodo WITH controlliamo che siano selezionati (altrimnenti mettiamo la spunta anche in)  WITH_CUBLAS, WITH_CUDA, WITH_OPENGL.

Intanto che compiliamo con CUDA compiliamo anche le CUDA Basic Linear Algebra Subroutines (cuBLAS) e il supporto per le OPEN_GL.

cmake_with

Ripremiamo “Configure” per fare il refresh e per vedere che questa volta la finestra centrale sia “bianca”.

Vi ricordo che ora è bianca perchè abbiamo tolto la spunta da BUILD_DOCS che cercava Doxygen e non per le altre configurazioni fatte.

cmake_ok

Se la finestra centrale è bianca e abbiamo “Configure done” allora è tutto Ok e possiamo cliccare su “Generate” per creare la soluzione Visual Studio.

cmake_generate

A questo punto dopo “Generating done” possiamo chiudere CMake e andare ad aprire la solution nella cartella dove abbiamo detto di crearla che nel mio caso è: C:\Users\fabio\Desktop\buildCuda

cmake_build_dir

Aprite la solutione, lanciate ALL_BUILD in Debug o Release e andate a prendere un caffè 🙂

Non vi è bastato vero il caffè? Sul mio PC impiega circa un’ora a Build (i7, 12GB ram, SSD HD).

vs13_cv3_debug

Una volta finito di Compilare lanciate la INSTALL.

Lanciate INSTALL che trovate in (CMakeTargets) per avere nella directory “install” le dll e librerie appena compilate

vs13_cv3_debug_install

vs13_cv3_debug_install_end

Ecco dove troverete le vostre DLL e LIB delle OpenCV compilate con CUDA

vs13_cv3_debug_install_end_dir

Io ora ho compilato in Debug.

Lanciando anche la compilazione in Release vedrete insieme le librerie di debug (*d.dll, *d.lib) assieme a quelle di release (*.dll, *.lib).

OpenCV 2.4.9

Per le OpenCV 2.4.9 il procedimento è praticamente identico, però ho dovuto impostare il CUDA_GENERATION dicendo esplicitamente la mia architettura ‘Kepler

cmake_cuda_generation

 

Altrimenti avevo l’errore di compilazione: Unsupported gpu architecture ‘compute_11’

Ho letto comunque che se si setta l’architettura specifica anche con le OpenCV 3.0 la compilazione è molto più veloce perchè non vengono compilati i file .cu per le altre architatture.

Senza specificarlo invece vengono compilati i .cu per tutte le architatture (GPU): Kepler, Fermi, etc…

E ho dovuto modificare il file NCV.cu (opencv-2.4.9\modules\gpu\src\nvidia\core\NCV.cu), andando ad includere il package “algorithm”:

#include <algorithm>

ncv.cu

Altrimenti mi dava l’errore: ‘max’ undefined error.

Compilare le OpenCV 3.0 con CUDA 7 e VisualStudio 2013 per x64

Trasformazioni nel piano

Visto che abbiamo appena parlato del cos(α-β) in un nostro precedente articolo (http://www.versionestabile.it/blog/cos-alpha-beta-ve-lo-ricordate) perché non parlare delle trasfromazioni nel piano, per arrivare ad ottenere la formula della rotazione di un punto rispetto ad un punto generico Ω(x0,y0)? 🙂

Traslazione

traslazione_a_aprimo

Un punto A viene traslato in A’ di Δx e Δy

Quindi: A^\prime = \begin{bmatrix} x \\ y \end{bmatrix}

Mentre A’ sarà: A^\prime = \begin{bmatrix} x^\prime \\ y^\prime \end{bmatrix} = \begin{bmatrix} x + \Delta x \\ y + \Delta y \end{bmatrix}

In rappresentazione matriciale potremmo scrivere

 A^\prime = T + A = \begin{bmatrix} \Delta x \\ \Delta y \end{bmatrix} + \begin{bmatrix} x \\ y \end{bmatrix}

Rotazione rispetto all’origine

rotazione rispetto origine

Qui abbiamo: A = \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} x = r\cdot\cos\alpha \\ y = r\cdot\sin\alpha \end{bmatrix}

Il suo punto A’ ruotato di β in senso antiorario sarà: A^\prime = \begin{bmatrix} x^\prime \\ y^\prime \end{bmatrix} = \begin{bmatrix} x^\prime = r\cdot\cos(\alpha + \beta) \\ y^\prime = r\cdot\sin(\alpha + \beta) \end{bmatrix}

Ecco che ci vengono in aiuto le tanto dimostrate formule del coseno e del seno della somma di angoli! 😀

A^\prime = \begin{bmatrix} x^\prime \\ y^\prime \end{bmatrix} = \begin{bmatrix} x^\prime = r\cdot\cos(\alpha + \beta) \\ y^\prime = r\cdot\sin(\alpha + \beta) \end{bmatrix} = \begin{bmatrix} x^\prime = r\cdot\cos\alpha\cos\beta - r\cdot\sin\alpha\sin\beta \\ y^\prime = r\cdot\sin\alpha\cos\beta) + r\cdot\cos\alpha\sin\beta \end{bmatrix}

Poichè

\begin{cases} x = r\cdot\cos\alpha \\ y = r\cdot\sin\alpha \end{cases}

A’ diventa:

A^\prime = \begin{bmatrix} x^\prime \\ y^\prime \end{bmatrix} = \begin{bmatrix} x^\prime = r\cdot\cos(\alpha + \beta) \\ y^\prime = r\cdot\sin(\alpha + \beta) \end{bmatrix} = \begin{bmatrix} x^\prime = r\cdot\cos\alpha\cos\beta - r\cdot\sin\alpha\sin\beta \\ y^\prime = r\cdot\sin\alpha\cos\beta) + r\cdot\cos\alpha\sin\beta \end{bmatrix} = \begin{bmatrix} x^\prime = x\cos\beta - y\sin\beta \\ y^\prime = y\cos\beta) + x\sin\beta \end{bmatrix}

In rappresentazione matriciale diventa $latex

A^\prime = R \cdot A = \begin{bmatrix} \cos\beta & -\sin\beta \\ \sin\beta & \cos\beta \end{bmatrix} \cdot \begin{bmatrix} x \\ y \end{bmatrix}

Scala

scala

Nell’immagine precedente si è ipotizzato: \begin{cases} scala x = s_x = \frac{1}{2} \\ scala y = s_y = \frac{1}{2} \end{cases}

Qui abbiamo: A = \begin{bmatrix} x \\ y \end{bmatrix}

Il suo punto A’ scalato di sx e sy lo scriviamo come: A^\prime = \begin{bmatrix} x^\prime \\ y^\prime \end{bmatrix} = \begin{bmatrix} x^\prime = x\cdot s_x \\ y^\prime = y\cdot s_y \end{bmatrix}

In rappresentazione matriciale diventa $latex

A^\prime = S \cdot A = \begin{bmatrix} s_x \\ s_y \end{bmatrix} \cdot \begin{bmatrix} x \\ y \end{bmatrix}

Trasformazioni nel piano

Formule trigonometriche della somma e differenza di due angoli

Con l’arrivo dell’Estate, ls scuole chiudono e io penso sempre a quanto era bello poter contare in 3 mesi di vacanze! 😀

E quanto ritorna la nostalgia mi viene da scrivere un po’ di formule matematiche.

Visto che avevo iniziato con la trigonometria… continuiamo con la trigonometria!

Dalla formula del coseno della differenza di due angoli otteniamo facilmene le formule per

\cos(\alpha+\beta)
\sin(\alpha-\beta)
\sin(\alpha+\beta)

sen_alfa_sen_pi_meno_alfa

sin_alfa_sin_meno_alfa
Dalle immagine sopra vediamo che:

\cos(\alpha) = \sin(\frac{\pi}{2}-\alpha)
\sin(\alpha) = \cos(\frac{\pi}{2}-\alpha)
\sin(-\alpha) = -\sin\alpha
\cos(-\alpha) = \cos(\alpha)

\cos(\alpha+\beta) = \cos\alpha\cos\beta - \sin\alpha\sin\beta

infatti

\cos(\alpha+\beta) = \cos(\alpha-(-\beta)) = \cos\alpha\cos(-\beta) + \sin\alpha\sin(-\beta) = \cos\alpha\cos\beta - \sin\alpha\sin\beta


\sin(\alpha+\beta) = \sin\alpha\cos\beta + \cos\alpha\sin\beta

infatti

\sin(\alpha+\beta) = \cos(\frac{\pi}{2}-(\alpha+\beta)) = \cos((\frac{\pi}{2}-\alpha)-\beta)) = \cos(\frac{\pi}{2}-\alpha)\cos\beta + \sin(\frac{\pi}{2}-\alpha)\sin\beta = \sin\alpha\cos\beta + \cos\alpha\sin\beta


\sin(\alpha-\beta) = \sin\alpha\cos\beta - \cos\alpha\sin\beta

infatti

\sin(\alpha-\beta) = \cos(\frac{\pi}{2}-(\alpha-\beta)) = \cos((\frac{\pi}{2}-\alpha)+\beta)) = \cos(\frac{\pi}{2}-\alpha)\cos\beta - \sin(\frac{\pi}{2}-\alpha)\sin\beta) = \sin\alpha\cos\beta - \cos\alpha\sin\beta

Formule trigonometriche della somma e differenza di due angoli

Intel i7 core0 90% CPU

Oggi da un mio cliente mi è capitata una cosa molto strana.

Ad un certo punto un programma che si è sempre eseguito velocemente nel mi laptop, improvvisamente andava lentissimo.

Dopo una breve diagnosi ho scoperto che il core0 del mio processore i7 era al 90% del suo quando il PC era idle e quando eseguivo il programma in questione andava al 100%! O_O

cpu0_100

Ho disinstallato i programmi che aveva installato dopo l’ultima volta che mi ricordavo che il programma funzionava correttamente e fatto anche un punto di ripristino… ma nulla…

Alla fine sapete cos’era? Staccando il cavo HDMI per il secondo monitor immediatamente il core0 è tornato a funzionare correttamente e anche riattaccandolo successivamente il problema non si ripresenta. Il problema si presenta solamente se avvio il PC con il cavo HDMI già collegato.

cpu0_100_hdmi

Il monitor che avevo dal mio cliente era un Asus.

Con l’HP che ho a casa non ho mai avuto questo problema… molto strano… ma per il momento non ho altre info in merito…

Intel i7 core0 90% CPU

Visualizzare i file nascosti su Mac Osx

Da terminale lanciare

defaults write com.apple.finder AppleShowAllFiles YES

E riavviare la “Finder app” cliccando ‘Alt’+pulsante destro sull’icona nel dock e scegliere “Relaunch” (o Riavvia se avete la lingua Italiana).

relunch_finder

Per ripristinare il default:

defaults write com.apple.finder AppleShowAllFiles NO

e rilanciare nuovamente il finder.

Visualizzare i file nascosti su Mac Osx

Bootstrap 3 with less

Se volete lavorare con Bootstrap 3 modificando i file .less e non volete installare o non conoscete Bower e Grunt allora un buon setup di strumenti di sviluppo multipiattaforma a mio avviso è:

  • SourceTree by Atlasssian per il versioning con Git
  • Sublime Text 2 per la modifica dei file html, php e less
  • Prepros App per la compilazione di file .less, .css (minify) e .js (minify)

Qui i riferiementi, alla data di scrittura dell’articolo, al download dei tool:

SourceTree
Sublime Text 2
Prepros App

Questa la configurazione per la compilazione su Prepros App dei file .less a partire dalla struttura di directory dei file sorgenti di bootstrap.

prepros.css.config

Una cosa che ho trovato differente rispetto ad altri preprocessori è nella gestione dei file minificati .min.css differenti rispetto ai file da cui derivano .css (senza suffisso .min) e questa:

Volendo generare sia i file.css e i loro minificati separati file.min.css occorre non settare il flag (compressCSS) sui file.css ma all’interno del progetto sul file generato file.css è qui che va messo il flag di minificazione (compressCSS).

Un’altra cosa da sapere è che Sublime Text non ha di default la sintassi per i file .less.

Se volete quindi installarla seguite le istruzioni che trovate qui: danro/LESS-sublime

Buon lavoro!

Alla prossima!

Bootstrap 3 with less

cos (α – β) ve lo ricordate?

L’altro giorno sono andato (… cosa volete è obbligatorio per i neo-iscritti) al corso di deontologia professionale dell’ordine degli ingegneri di Ravenna. Poiché tra un discorso interessante e l’altro c’erano anche discorsi un po’ noiosi mi è venuta la voglia di fare qualche dimostrazione matematica dei vecchi studi… e visto che ultimamente l’ho usato spesso, proprio la dimostrazione di cos (α-β).

Poi metterò anche le pagine del mio blocco appunti così vedete che è vero che gli ingegneri sono un po’ matti 🙂

La dimostrazione di cos(α-β) è la base per la facile dimostrazione delle formule gemelle

cos (α-β)
sin (α-β)
sin (α+β)

cos (α-β) = ?

ab_aprimobprimo

 

Il segmento AB sulla circonferenza con c’entro nell’origine lo trasliamo di un angolo β in modo che il punto B vada a coincidere sull’asse x.

Deve ovviamente essere: \overline{AB}=\overline{A'B'}

pitagora

Per il famoso Pitagora

\overline{AB} = \sqrt{(x_A-x_B)^2+(y_A-y_B)^2}

Ed anche

\overline{A^\prime B^\prime} = \sqrt{(x_A^\prime-x_B^\prime)^2+(y_A^\prime-y_B^\prime)^2}

E imponiamo l’uguaglianza dei segmenti:

\overline{AB} = \overline{A^\prime B^\prime}

Poiché abbiamo tutte componenti positive possiamo elevare al quadrato e avere:

\overline{AB}^2 = \overline{A^\prime B^\prime}^2

Quindi

(x_A-x_B)^2+(y_A-y_B)^2 = (x_A^\prime-x_B^\prime)^2+(y_A^\prime-y_B^\prime)^2

Sempre dalla trigonometria risulta che:

A = \begin{cases} x_A=r \cdot cos\alpha \\ y_A = r \cdot sin\alpha \end{cases}

e

B = \begin{cases} x_A=r \cdot cos\beta \\ y_A = r \cdot sin\beta \end{cases}

e

A^\prime = \begin{cases} x_A=r \cdot cos(\alpha-\beta) \\ y_A = r \cdot sin(\alpha-\beta)) \end{cases}

e

B^\prime = \begin{cases} x_A=r \cdot cos(\beta-\beta) \\ y_A = r \cdot sin(\beta-\beta)) \end{cases}

Quindi

\overline{AB}^2 = (r\cdot cos\alpha - r\cdot cos\beta)^2+(r\cdot sin\alpha-r\cdot sin\beta)^2

e

\overline{A^\prime B^\prime}^2 = (r\cdot cos(\alpha-\beta) - r\cdot cos0)^2+(r\cdot sin(\alpha-\beta) - r\cdot sin0)^2 = (r\cdot cos(\alpha-\beta) - r)^2+(r\cdot sin(\alpha-\beta))^2

Imponiamo di avere un raggio pari ad 1: r=1

Abbiamo:

\overline{AB}^2 = \cos^2\alpha + \cos^2\beta - 2\cos\alpha\cos\beta + \sin^2\alpha + \sin^2\beta-2\sin\alpha\sin\beta

e

\overline{A^\prime B^\prime}^2 = \cos^2(\alpha-\beta) + 1 - 2\cos(\alpha-\beta) + \sin^2(\alpha-\beta)

Poiché equivale l’uguaglianza: \cos^2\theta + \sin^2\theta = 1

Abbiamo

\overline{AB}^2 = (\cos^2\alpha + \sin^2\alpha) + (\cos^2\beta + \sin^2\beta) - 2\cos\alpha\cos\beta -2\sin\alpha\sin\beta = 1 + 1 - 2\cos\alpha\cos\beta -2\sin\alpha\sin\beta = 2 - 2\cos\alpha\cos\beta -2\sin\alpha\sin\beta

e

\overline{A^\prime B^\prime}^2 = (\cos^2(\alpha-\beta) + \sin^2(\alpha-\beta))+ 1 - 2\cos(\alpha-\beta) = 1 + 1 - 2\cos(\alpha-\beta) = 2 - 2\cos(\alpha-\beta)

Quindi se \overline{AB}^2 = \overline{A^\prime B^\prime}^2

si ha:
2 - 2\cos\alpha\cos\beta - 2\sin\alpha\sin\beta = 2 - 2\cos(\alpha-\beta)

(2 - 2) - 2\cos\alpha\cos\beta - 2\sin\alpha\sin\beta = - \cos(\alpha-\beta)

2\cos(\alpha-\beta) = 2\cos\alpha\cos\beta + 2\sin\alpha\sin\beta

\cos(\alpha-\beta) = \cos\alpha\cos\beta + \sin\alpha\sin\beta

CVD.

Lo so… gli ingegneri tendono alla follia a volte… 😀

cos_alpha_men_beta_1

cos_alpha_men_beta_2

alpha_men_beta_3

cos (α – β) ve lo ricordate?

Debugging .NET application con WinDbg

E’ possibile creare un file minidump anche per applicazioni .NET nello stesso modo descritto nell’articolo per le applicaizoni native:

http://www.versionestabile.it/blog/dubugging-with-windbg/

Per le applicazioni .NET è più difficile avere la riga di codice esatta, soprattutto se non si è tenuto il file .pdb della versione che ha fatto il “crash” a casa del cliente e non vengono caricati correttamente anche i symboli delle classi .NET relative al Framework con cui è stato compilato il programma in question.

Per prima cosa lanciare il caricamento del framework

.loadby sos clr

Comunque anche se si dispone solo del file .dump (vedere come generarlo nell’articolo citato sopra) se lo si apre con WinDBG e si analizzano al suo interno le eccezioni con il comando

!analyze -v

Si può vedere lo stack trace che ci porta al punto di programma incriminato.

Vediamo un esempio.

Il programma C# del nostro esempio è il seguente:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WinDbgCrashTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            badMethod();
        }

        private void badMethod() {
            Object o = null;
            String s = o.ToString();
        }
    }
}

Se lo si lancia andrà in Crash immediato.

Apriamo il suo minidump con WinDBG e lanciamo !analyze -v

Lancirare WinDbg come amministratore in modo che possa scaricare (dal sito di Microsoft) nelle cartelle di sistema i simboli che eventualmente non trova in locale.

Ecco il risultato:

windbg_net_crash1
Anche se non è riuscito a caricare i simboli

crash_net_windbg_0
ci dice che alla riga 2 del metodo badMethod all’interno della classe Form1 si è verificata l’eccezione!

Se diamo a WinDBG il path del .pdb e dei sorgenti che fanno riferimento a quell’eseguibile con il comando

!clrstack

Abbiamo anche più info: il file e la riga dove è avvenuta l’eccezione.
crash_net_windbg

Debugging .NET application con WinDbg