Convertire una combobox in checkbox con jQuery

Se non avete accesso all’html di un CMS e volete cambiare una textbox in una checkbox, ecco il codice jQuery che ve lo fa fare!
Enjoy!!!

<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<script type="text/javascript" src="https://code.jquery.com/jquery-1.11.2.min.js"></script>
		<script src="https://code.jquery.com/jquery-migrate-1.2.1.js"></script>
	</head>
	<body>
		<select size="1" name="mySelect" id="mySelect">
			<option selected="selected" value="Any">Hello</option>
			<option value="1">Questo è una</option>
			<option value="2">Textbox</option>
			<option value="3">In realtà :O)</option>
		</select>			
	</body>
</html>

<script type="text/javascript">
$(function(){
	//$(".main_container select").selectbox();
	$('select').each(function(i, select){
	    var $select = $(select);
	    $select.find('option').each(function(j, option){
	        var $option = $(option);
	        // Create a radio:
	        var $radio = $('<input type="radio" />');
	        // Set name and value:
	        $radio.attr('name', $select.attr('name')).attr('value', $option.val());
	        // Set checked if the option was selected
	        if ($option.attr('selected')) $radio.attr('checked', 'checked');
	        
	        // Insert radio before select box:
	        $select.before($radio);

	        //wrap radio in div
	        $radio.wrap( "<div class='radio_button'></div>" );
	        
	        // Insert a label:
	        $radio.after(
	          $("<label />").text($option.text())
	        );
	        // Insert a <br />:
	        //$select.before("<br/>");
	    });
	    $select.remove();
	});
})
</script>

Salvatelo come file Html e provatelo 😉

Convertire una combobox in checkbox con jQuery

Rotazione rispetto ad un punto generico Ω(x0,y0)

Adesso che nell’articolo sulle Coordinate Omogenee abbiamo imparato a comporre le trasformazioni nel piano possiamo facilmente ricavarci la formula di un punto ruotato rispetto ad un punto generico \Omega(x_0,y_0).

Per ottenerla basta applicare una operazione di traslazione T_1 nell’origine del punto A, una rotazione rispetto all’origine R di A e successivamente una nuova traslazione T_2 che riporti A al suo posto 🙂

Quindi: A^\prime = T_2\cdot R\cdot T_1\cdot A = \begin{bmatrix} 1 & 0 & x_0 \\ 0 & 1 & y_0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} \cos\beta & -\sin\beta & 0 \\ \sin\beta & \cos\beta & 0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & -x_0 \\ 0 & 1 & -y_0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}

Ovvero:

A^\prime = T_2\cdot R\cdot T_1\cdot A = \begin{bmatrix} \cos\beta & -\sin\beta & x_0 \\ \sin\beta & \cos\beta & y_0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & -x_0 \\ 0 & 1 & -y_0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}

Ovvero:

A^\prime = T_2\cdot R\cdot T_1\cdot A = \begin{bmatrix} \cos\beta & -\sin\beta & -x_0\cos\beta+y_0\sin\beta+x_0 \\ \sin\beta & \cos\beta & -x_0\sin\beta-y_0\cos\beta+y_0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}

Quindi la matrice di rotazione rispetto a \Omega(x_0,y_0) è

R = \begin{bmatrix} \cos\beta & -\sin\beta & -x_0\cos\beta+y_0\sin\beta+x_0 \\ \sin\beta & \cos\beta & -x_0\sin\beta-y_0\cos\beta+y_0 \\ 0 & 0 & 1 \end{bmatrix}

E il punto A^\prime è:

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

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

Rotazione rispetto ad un punto generico Ω(x0,y0)

NVCC compile PTX with virtual code or for specific architecture

Se compiliamo con NVCC in modo che utilizzi un Virtual Code possiamo utilizzare il programma su qualunque architettura di GPU però abbiamo un delay allo startup dell’applicazione, come descritto a pagina 25 del manuale di NVCC di CUDA 7.

CUDA_Compiler_Driver_NVCC.pdf

Che si trova nel seguente direttorio: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\doc\pdf

“By specifying a virtual code architecture instead of a real GPU, nvcc postpones theassembly of PTX code until application runtime, at which the target GPU is exactlyknown. For instance, the command below allows generation of exactly matching GPUbinary code, when the application is launched on an sm_20 or later architecture.nvcc x.cu –gpu-architecture=compute_20 –gpu-code=compute_20The disadvantage of just in time compilation is increased application startup delay,but this can be alleviated by letting the CUDA driver use a compilation cache (refer to”Section 3.1.1.2. Just-in-Time Compilation” of CUDA C Programming Guide) which ispersistent over multiple runs of the applications.”

 

 

NVCC compile PTX with virtual code or for specific architecture

Coordinate omogenee

Non possiamo con la rappresentazione matriciale presentata nell’articolo sulle Trasformazioni Nel Piano concatenare la rotazione e la scala con la traslazione. Questo perché in questo secondo caso abbiamo una somma matriciale e nei primi due abbiamo una moltiplicazione.
Possiamo però riscrivere le matrici nel cosiddetto “sistema di riferimento omogeneo”. Non starò qui a spiegare il concetto di sistema di riferimento omogeneo, dirò solo che un punto A la cui rappresentazione matriciale è \begin{bmatrix} x \\ y \end{bmatrix} nel sistema di riferimento omogeneo diventa \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}
Le rispettive matrici di trasformazione diventano:

Traslazione: T = \begin{bmatrix} 1 & 0 & \Delta x \\ 0 & 1 & \Delta y \\ 0 & 0 & 1 \end{bmatrix}

Rotazione: R = \begin{bmatrix} \cos\beta & -\sin\beta & 0 \\ \sin\beta & \cos\beta & 0 \\ 0 & 0 & 1 \end{bmatrix}

Scala: S = \begin{bmatrix} sx & 0 & 0 \\ 0 & sy & 0 \\ 0 & 0 & 1 \end{bmatrix}

Vediamo se i conti ci tornano 🙂
Questa volta possiamo utilizzare la moltiplicazione tra matrici anche per la Traslazione.

Traslazione

A^\prime = T \cdot A = \begin{bmatrix} 1 & 0 & \Delta x \\ 0 & 1 & \Delta y \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix} = \begin{bmatrix} x + \Delta x \\ y + \Delta y \\ 1 \end{bmatrix}

Che è esattamente il nostro punto traslato in coordinate omogenee.

Rotazione

A^\prime = T \cdot A = \begin{bmatrix} \cos\beta & -\sin\beta & 0 \\ \sin\beta & \cos\beta & 0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix} = \begin{bmatrix} x\cdot\cos\beta - y\cdot\sin\beta \\ x\cdot\sin\beta + y\cdot\cos\beta \\ 1 \end{bmatrix}

Che è esattamente il nostro punto ruotato in coordinate omogenee.

Scala

A^\prime = T \cdot A = \begin{bmatrix} s_x & 0 & 0 \\ 0 & s_y & 0 \\ 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix} = \begin{bmatrix} x\cdot s_x \\ y\cdot s_y \\ 1 \end{bmatrix}

Che è esattamente il nostro punto scalato in coordinate omogenee.

Regola di composizione

Quando si compongono 2 o più trasformazioni la precedente è sempre a destra della successiva. Ovvero se abbiamo 3 trasformazioni \Theta_1, \Theta_2, \Theta_3 che vengono fatte in sequenza: Prima \Theta_1, poi \Theta_2 e per ultima \Theta_3 il punto A’ sarà dato da:

A^\prime = \Theta_3\cdot\Theta_2\cdot\Theta_1\cdot A

Coordinate omogenee

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