venerdì 30 marzo 2018

Modello digitale del terreno con Google DayDream ed Unity

In questo post il metodo che ho usato per mostrare dati di modelli digitali del terreno con Unity ed il visore DayDream di Google

Il progetto che ho creato e'  di tipo Android. Nel Player Settings del progetto sotto XR Settings deve essere spuntato il supporto alla realta' virtuale e si aggiunge DayDream tra gli SDK. Sempre nel Player Settings si deve impostare in Other Settings un Minimum Level API a livello 24

Sicilia con Etna

Per prima cosa si crea il modello digitale.
L'immagine deve essere a scala di grigi, in cui il livello di grigio indica la quota sul livello del mare (nero equivale a livello piu' basso, spesso il livello del mare, il bianco e' la quota piu' alta)

Si crea un oggetto Terrain da GameObject/3D/Terrain con dimensioni pari a quelle del modello DEM
Si trascina l'immagine negli assets del progetto e si prende il file HeightmapfromTexture. Dalle proprieta' dell'immagine (a destra Advanced si deve spuntare Read/Write and Apply)
L'editor delle versioni moderne di Unity (Unity 3d 2017.2) non permettono di editare direttamente file JavaScript. Si copia quindi lo script in un editor e si aggiungono le seguenti linee (dove si dichiarano le variabili x ed y)

    var mapColors = heightmap.GetPixels();
    var map = new Color[w2 * w2];
    var y = 0.0;
    var x = 0.0;



 si salva il file e lo si trascina negli assets del progetto.

Si selezione negli assets l'immagine DEM importata e si clicca sul menu' in alto Terrain/HeightMapFromTexture

Per settare il livello di amplificazione delle quote si cambia il valore di Terrain Height nell'inspector

Il modello usato e' poco dettagliato 2048x2048 pixels


Una volta importato e settato il modello digitale si deve aggiungere il supporto DayDream a Unity.
Una volta scaricato il package Daydream per Unity e lo aggiunge al progetto con il menu Assets/Import Package/Custom/GoogleVRforUnity.unitypackage.


  • Si aggiunge quindi alla Hierarchy il modulo GvrEditorEmulator
  • Si crea quindi un GameObject (dal menu' in alto), Gameobject/Create Empty e si rinomina come Player
  • Si trascina la camera e si inserisce nell'albero sotto l'oggetto Player
  • Si aggiungono GvrControllerMain e GvrEventSystem
  • Se il progetto include una canvas deve essere aggiunto GvrPointerGraphicsRaycaster da Add Component
  • Si aggiunge GvrPointerPhysicsRaycaster alla Camera da Add component
  • Si aggiunge GvrControllerPointer agganciandolo al Player

giovedì 29 marzo 2018

Riconoscimento automatico targhe automobilistiche

Ho letto sul giornale che i Vigili Urbani di Firenze hanno a disposizione un sistema automatico di lettura delle targhe automobilistiche in modo da interrogare poi un database della motorizzazione per elevare multe...mi sono chiesto...quanto e' complicato questo metodo??

Avevo letto che la libreria OpenCV permetteva di fare il riconoscimento automatico ma frugando ho trovato un prodotto gia' fatto ovvero OpenALPR,,vale la pena provarlo facendo una prova veloce

(ps. per motivi di privacy le targhe sono oscurate, fidatevi che i risultati sono corrispondenti alla realta')

Fornendo all'algoritmo questa foto



Si ha come risultato questa lista. Il primo candidato, quello con il punteggio piu' alto, corrisponde al vero numero di targa.


Non tutte le immagini forniscono dati corretti e per assurdo se si fotografa una targa in primissimo piano l'algoritmo fallisce miseramente

Piccoli artisti crescono



Mamma e babbo

mercoledì 28 marzo 2018

Frecce Tricolori su Firenze 28 Marzo 2018











per cercare di fare partire il tempo la registrazione sbirciavo su un cellulare FlightRadar24 nella speranza che gli aerei delle Frecce avessero i transponder accesi....no...i militari a quanto pare non usano questo sistema ....in ogni caso ho avuto l'indicazione che la pattuglia era in zona quando un volo civile ha iniziato un circuito di attesa prima di entrare nell'area fiorentina


lunedì 26 marzo 2018

Immagini Raw su Gimp ed Android

Scattare una foto con un telefono cellulare e' semplice, scattare una foto con una resa cromatica soddisfacente non e' banale.

Per prima cosa si deve scattare una foto salvando i dati in formato Raw. Cio' non e' possibile con tutte le fotocamere dei telefoni (per quelli piu' costosi in genere si') e bisogna in ogni caso appoggiarci ad applicazioni esterne come AZ Camera (una delle poche che permette il salvataggio raw in modo gratuito). Lo scatto avra' una estensione .dng (il formato DNG non e' esattamente coincidente con il formato RAW ma per quello che seguira' non ci sono significative differenze) ed avra' la dimensione di qualche decina di Mb

Per avere dei colori fedeli si deve includere nell'immagine anche una tavola dei colori di riferimento come la CheckerColor di X-Rite. Si tratta di un oggetto molto costoso, sul centinaio di  euro al momento, che e' formato da 24 mattonelle di colore omogeneo e calibrato


Se si include la tavola di riferimento nell'immagine si puo' poi usare il software ColorChecker Camera Calibration che elabora l'immagine, trova il riferimento e crea un file .dcp di riferimento per la fotocamera (attenzione, se la foto e' sovraesposta il software non funziona)

A questo punto con il programma dpc2icc si puo' convertire il profilo camera in .icc, il formato desiderato da Gimp. (attenzione: per la conversione e' necessario inserire la temperatura di colore)

Di default Gimp non sa gestire i file raw ed e' necessario installare il pluging ufraw. Scaricando pero' questo pacchetto si trova Gimp con gia' incluso il pacchetto ufraw. Aprendo un file .dng si apre in automatico ufraw


Da qui si possono impostare le impostazioni della camera importando il file .icc. Premendo Ok l'immagine corretta viene quindi inviata a Gimp per le successive modifiche

A questo punto non e' finita....avere una foto cromaticamente calibrata non vuol dire che riusciamo a vederla a monitor con i colori giusti perche' anche il monitor (o lo schermo del telefono) deve essere calibrato mediante apposite applicazioni (tipo ColorTrue di X-Rite per Android) ed appositi dispositivi hardware chiamati colorimetri (tipo ColorMunki X-Rite del costo di un centinaio di euro)

In conclusione ottenere i colori corretti su PC o Android e' piuttosto costoso....

Estendere raggio d'azione dei beacons


Ho fatto una prova per estendere il raggio di ricezione del segnale dei Beacons Estimote. Per questo motivo ho preso un dongle USB Bluetooth 4.0 con connessione antenna SMA ed una antenna esterna direzionale della TP-LinK, anche questa dotata di connettore SMA



L'antenna e' nata per WiFi ma visto che sia WiFi che BT lavorano a 2.4 GHz non ci sono problemi

Le misure sono state fatte con un programma Python allontanandosi via via dall'antenna. In una prova di un beacon in modalita' Eddystone sono partito con un valore di RSSI di circa -46 per arrivare a circa 140 m di distanza ad un valore di RSSI -96.


Vettore normale su nuvola di punti

Il problema e' questo : data una nuvola di punti, generata da un sensore come Kinect, determinare i vettori normali delle superfici triangolari che hanno come vertici i punti della nuvola stessa.
Il sistema di coordinate ha l'asse Z orientato come la distanza dal sensore, X ed Y invece sono lungo la dimensione della matrice di acquisizione

Presi tre punti nello spazio (x1,y1,z1),(x2,y2,z2),(x3,y3,z3) non allineati (questa condizione visto che i dati vengono da uno strumento di misura reale diciamo che e' soddisfatta a priori) per calcolare l'equazione del piano si deve calcolare il determinante della seguente matrice con la condizione che sia uguale a zero

(x-x1,   y-y1, z-z1,
 x2-x1, y2-y1, z2-z1,
 x3-x2, y3-y2, z3-z2)

con la formula di Laplace per il determinante si ha che (x,y,z sono le variabili)

(x-x1)[(y2-y1)(z3-z1)-(y3-y1)(z2-z2)] - (y-y1)[(x2-x1)(z3-z1)-(x3-x1)(z2-z1)]+ (z-z1)[(x2-x1)(y3-y1)-(x3-x1)(y2-y1)]= 0

si ha cosi' un risultato nella forma

ax+by+cz = 0

una volta calcolato il piano si deve calcolare la normale (nx,ny,nz)si calcola la derivata parziale 

F = ax +by+cz

nx = dF/dx, ny = dF/dy, nz = dF/dz.

Visto che si tratta di un piano la derivata parziale e' banale e le componenti del vettore normale sono (a,b,c)

-----------------------------------------------------------
Un metodo alternativo (che non prevede di calcolare prima l'equazione di un piano) e' quella di calcolare il prodotto vettoriale tra i due del triangolo). Per esempio dati sempre i tre punti (x1,y1,z1),(x2,y2,z2),(x3,y3,z3) si prendono due vettori

v = (x2-x1, y2-y1, z2-z1)
w = (x3-x1, y3-y1, y3-y1)

il vettore normale e' dato dal determinante della matrice

(x,y,z
v1 ,v2 ,v3,
w1,w2,w2)

n = u X v = (v2w3-v3w2)x+(v3w1-v1w3)y+(v1w2-v2w1)z


Adesso c'e il problema e' di normali ce ne sono due essendo la superficie orientata (brutalmente una sotto ed una sopra al piano) oppure nel prodotto vettoriale dipende dall'ordine con cui si pongono i vettori (vXw e' diverso da wXv)

A questo punto si puo' procedere normalizzando il vettore.

nn1 = n1/sqrt(n1n1+n2n2+n3n3)
nn2 = n2/sqrt(n1n1+n2n2+n3n3)
nn3 = n3/sqrt(n1n1+n2n2+n3n3)

il passaggio da coordinate cartesiane a coordinate.




Se si guarda la libreria PCL la ricostruzione della normale ad una superficie viene effettuata mediante il calcolo delle componenti principali che permette anche di gestire anche che l'orientazione delle normali sia coerente 

mercoledì 21 marzo 2018

Rough AP

Ancora una domanda: ma se mi connetto ad un access point pubblico quali rischi si possono correre?? Ho provato a montarmi un Access Point per auto rubarmi le credenziali di accesso alla mia webmail lavorativa (Squirrel Mail su un accesso HTTP ..non HTTPS)

La cosa e' stata particolarmente banale. Per l'Access Point ho visto che c'erano molte alternative ma alla fine quella piu' semplice e' stata quella di usare WiFi Pumpkin.



Per recuperare le credenziali di accesso ho usato net-creds.py.
Il login e la password recuperati hanno necessitato 10 minuti di lavoro...non di piu'
Si ..vabbe'...ma HTTPS ?? Non ho provato ma qualcosa mi dice SSLSTRIP ... non funziona ovunque ma e' sempre una possibilita'

lunedì 19 marzo 2018

Nascondersi su una LAN

Mi e' venuta una domanda e provo a rispondermi...e' possibile nascondere completamente un dispositivo, per esempio Linux, su una LAN?

Iniziamo con le cose semplici. Per nascondersi da una scansione di port scanning tipo NMAP sicuramente bisogna non esporre nessun servizio di rete. Questo e' facile perche' basta configurare una regola del firewall della propria macchina che droppando (DROP su Iptables o simil) tutte le connessioni in ingresso.

Rimane il problema che alcuni tipi di demoni (tipo AVAHI) generano automaticamente traffico in uscita rendendovi visibili a livello di traffico sulla macchina di frontiera. Ovviamente la macchina deve essere configurata anche con un IP statico in modo da non fare richieste al DHCP server

E fino qui cose semplici...rimane il protocollo ARP, il responsabile di associare il MAC Address ad un IP. Per lavorare uno switch od un router devono avere una tabella di conversione tra MAC Address ed IP. Tale tabelle viene generata inviando delle pacchetti ARP Request a cui ogni client risponde dando le proprie generalita' di rete oppure monitorando in modo passivo il traffico di rete tenendo nota delle coppie IP-MAC (poi ci sono gli accoppiamenti statici ma questi vengono generati dall'amministratore di sistema direttamente nello switch e non sono di interesse)

E' possibile disabilitare le risposte del protocollo ARP ma cio' impedirebbe immediatamente alla macchina le sue funzionalita' di rete...si potrebbe solo vedere il traffico in modo completamente passivo in modalita' promiscua ma su una rete switchata, come sono praticamente tutte adesso, non avrebbe alcun senso.

In conclusione e' possibile nascondersi completamente in una lan come un computer spento o come un terminale con il cavo di rete staccato...non facendo niente

venerdì 16 marzo 2018

Elks Linux per 8086

Era circa la meta' degli anni 90 quando si iniziava a sentire parlare di Linux ma io non potevo provarlo perche' usavo ancora un Olivetti M24 con processore 8086 mentre Linux ha sempre richiesto un processore minimo della classe 386.
A distanza di cosi' tanti anni ho scoperto che esiste un progetto, peraltro datato 1995, per usare un sottoinsieme del kernel Linux su processori 8086. Questo progetto si chiama Elks e non potevo fare a meno di provarlo (la sigla sta per Embeddable Linux Kernel Subset). Le FAQ in italiano si trovano qui qui e qui



Ho iniziato cercando di compilare tutto dai sorgenti ma ho avuto un bel po' di problemi anche seguendo pedissequamente le istruzioni...per scoprire che esistono delle immagini floppy gia' pronte

Non volendo tirare fuori dalla mia collezione un vero PC XT 8086 e' possibile provare ELKS in DOSEMU. Basta andare in /etc/dosemu/dosemu.conf ed indicare nel parametro $_vbootfloppy come immagine disco la path per esempio full3 ed avviare con

dosemu -A

giovedì 15 marzo 2018

Rubber Duck clone con Arduino Leonardo

Rubber Ducky e' un dispositivo di Hak5 che permette di effettuare penetration testing su macchine a cui si ha accesso fisico. In pratica si tratta di un dispositivo che viene visto dal computer come una tastiera e che invia caratteri tastiera da uno script predefinito come se fosse un utente umano. Lo script puo' essere configurato in modo da compromettere il terminale.
Qualcosa di simile e' BadUSB anche se in questo caso si prende una chiavetta di memoria USB che agisce come tastiera ma mantiene anche le sue caratteristiche di espansione di memoria.

Esempio di script automatico in esecuzione su Ubuntu Keyboard US Layout

E' possibile fare qualcosa di simile anche con una Arduino Leonardo dato che anche questa scheda ha una funzionalita' di tastiera. Io ho acquistato un mini clone di Arduino Leonardo

La scheda originale viene programmata mediante un suo linguaggio di scripting ed a questo link sono disponibili vari payload (sia innocui che offensivi)
Per convertire i payload da Rubber Ducky a Arduino Leonardo si puo' usare il comodo servizio online https://nurrl.github.io/Duckuino/.

Attenzione : gli script sono sia funzione del sistema operativo che del layout della  tastiera
Dal sito viene scaricato un file .zip con lo script .ino e Keyboard.h e Keyboard.cpp...non si tratta della libreria Keyboard di Arduino...nel file Keyboard.cpp si trova la configurazione del layout di tastiera desiderato (per esempio US od IT)

Per compilare lo sketch su Linux ho dovuto modificare il file Keyboard.h eliminando la riga

#include "HID.h"

inoltre il comando dell'esempio Hello World


Keyboard.press("r");

deve essere modificato in (il carattere e' incluso in apici singoli, la stringa in apici doppi)

Keyboard.press('r');

Un po' di note
1) Una volta caricato il payload questo viene mandato subito in esecuzione. In caso di payload malevolo puo' compromettere anche la macchina di sviluppo.Per questo motivo e' fortemente consigliato di inserire un delay nell'avvio del payload in modo da dare il tempo di disinserire la chiavetta.

2) Su Linux e Mac funziona tutto magnificamente ed in modo trasparente. Se si connette la schedina ad un computer Windows e si tenta di usare un payload malevole la cosa sara' molto meno trasparente perche' Windows si accorge che oltre all'interfaccia HID trova anche due dispositivi Arduino e tenta di scaricare i driver da Internet. Per evitare questa cosa ci sarebbe da pasticciare sui files boards.txt and USBDescriptor.h di Arduino IDE ma al momento non ho tempo di provarci





lunedì 12 marzo 2018

Programmare HP 95LX

In questo post avevo mostrato un esempio di retrocomputing, un HP 95 LX pocket computer MS-DOS 8088 compatibile.


In questa foto si vede il programma funzionare ma per un errore sul puntatore di fine stringa viene mostrato anche il contenuto della memoria....una cosa che succedeva in ASM su MS-DOS 


Come indicato nella memoria e' disponibile solo COMMAND.COM e non ci sono comandi MS-DOS esterni quindi nemmeno EDLIN od altri editor piu' complessi e non era disponibile nemmeno un compilatore (tipo GW-Basic).....il problema e' che volevo provare a farci girare un mio programma.

Il problema di non avere un editor e' stato risolto con il comando interno DOS

COPY CON nome_file

Dopo aver dato invio tutti gli input da tastiera vengono inviati al file. Per terminare CTRL+Z ed Invio

Per creare un programma eseguibile si puo' usare COPY CON ed inputare codici in linguaggio macchina. Per esempio si prende un semplice programma Assembler

     org  0x100        ; .com files always start 256 bytes into the segment

    ; int 21h is going to want...

    mov  dx, msg      ; the address of or message in dx
    mov  ah, 9        ; ah=9 - "print string" sub-function
    int  0x21         ; call dos services

    mov  dl, 0x0d     ; put CR into dl
    mov  ah, 2        ; ah=2 - "print character" sub-function
    int  0x21         ; call dos services

    mov  dl, 0x0     ; put LF into dl
    mov  ah, 2        ; ah=2 - "print character" sub-function
    int  0x21         ; call dos services

    mov  ah, 0x4c     ; "terminate program" sub-function
    int  0x21         ; call dos services

Lo si compila su una macchina ospite e con un editor esadecimale si legge il risultato che e' qualcosa del tipo

Fino a qui la cosa potrebbe anche funzionare ma ci si ferma subito perche' si vede che alcuni codici non sono presenti sulla tastiera...come fare l'input di tali codici?? Mi sono ricordato che ai tempi del Turbo Pascal 5.0 su M24 per fare le parentesi graffe (non presenti sulla tastiera italiana) all'epoca usavo la conbinazione ALT+123. 

Cosi convertendo in decimale l'output esadecimale del compilatore e digitando ognuno dei numeri seguenti preceduti da ALT ed usando COPY CON si puo' creare un file .COM eseguibile

--------------------------------------------------------
186
23
1
180
9
205
33
178
13
180
2
205
33
178
5
180

2
205
33
180
76
205
33
76
117
99
97
36
--------------------------------------------------------

complicato ma funzionante


venerdì 9 marzo 2018

HP 95LX

Un pocket computer primi anni 90 della HP (compresa calcolatrice HP!) del 1991.
Il dispositivo e' perfettamente funzionante e funziona con due semplici pile AA.
E' interessante che e' un dispositivo con un processore NEC V20 compatibile 8088 che permette l'esecuzione di MSDOS e delle relative applicazioni (l'unico limite e' lo schermo) con 512 Kb di memoria


MS DOS 3.22 in esecuzione
La versione MS DOS installata e' la 3.22 ma c'e' solo COMMAND.COM. Non sono presenti i comandi esterni del DOS . Per uscire dalla modalita' DOS digitare EXIT

Gioco Tiger e Fox (TF.COM)

File Manager

Impostazioni. Digitare CONFIG 
 Unica pecca... non c'e' il compilatore integrato

Luna Vs Andromeda

....and the winner is...Andromeda


Confronto dimensioni tra Andromeda e Luna
https://www.reddit.com/r/space/comments/339nzp/apparent_size_of_the_moon_and_andromeda_in_our/

Spiegazione : leggendo il libro on line di Paolo Attivissimo al punto 7.6  si trova la seguente frase

 "Per esempio, la galassia di Andromeda, nonostante stia a ben due milioni di anni luce (19 milioni di milioni di milioni di chilometri) dalla Terra, nel cielo notturno appare più grande della Luna piena"

la frase mi ha lasciato un po' perplesso perche' e' abbastanza contraria all'esperienza diretta osservando ad occhio nudo il cielo...ho quindi chiesto informazioni a chi piu' esperto di me e nei commenti mi e' stato confermato che la Luna sottende circa mezzo grado mentre Andromeda ben tre gradi..Andromeda ha quindi una dimensione apparente di circa 6 volte piu' grande della Luna piena.

Cio' che inganna l'occhio e' che la luminosita' di Andromeda scende rapidamente verso la periferia della galassia, cosa che non accade ovviamente con la Luna

giovedì 8 marzo 2018

Testing EC2 Amazon

Note dopo il primo utilizzo
1) la macchina e' visibile solo in una Region ed e' quella in cui e' stata creata. Per esempio
ieri avevo creato una macchina in  eu-west-3c (Paris) mentre oggi mi sono collegato alla console di EC2 nella Region eu-central-1 (Francoforte). La macchina era raggiungibile sia via SSH che HTTP quindi era viva, semplicemente non era visibile nella web console. E' stato sufficiente settare la giusta Regione per farla riapparire (il controllo e' in alto a destra vicino all'account)



2) si possono creare anche piu' istanze (per esempio una Linux ed una Windows). Il problema e' che l'istanza Linux ha di base 8 Giga di spazio disco mente quella Windows 30 Giga. Se si attivano entrambe si sfora il limite di 30 Giga di spazio disco gratuito. Inoltre il livello gratuito consente un tempo di uso di 750 ore che corrisponde ad un mese 24x7. Se si usano due macchine il tempo si dimezza..si possono tenere accese in contemporanea solo per 15 giorni senza pagare.


-------------------------------------------------------------------------------

Questi sono i passi per configurare la propria macchina ..non tutte le opzioni (AMI = Amazon Machine Image) sono comprese per la prova gratuita. Io sono partito con una Red Hat Enterprise 7.4.
L'istanza di base e' una t2.micro

Il passo 2 e' obbligato perche' c'e' una sola scelta per il livello gratuito



la macchina viene configurata con tutte le porte chiuse. Si deve quindi abilitare esplicitamente la porta 22 per l'amministrazione SSH


La dimensione di default del disco e' di 10 Gb

Per collegarsi in SSH non viene usato usato il sistema user/pass ma la chiave privata. Si deve quindi creare una coppia di chiavi e scaricarla sul proprio client

alla fine si lancia l'istanza per far partire la macchina

Dalla consolle di amministrazione di EC2 si puo' vedere lo stato della macchina, il suo indirizzo DNS pubblico, il suo IP



queste informazioni sono necessarie per collegarsi in SSH
Da Linux e Mac la sintassi e' la seguente (AmazonEC2.pem e' il nome del file della mia chiave, ec2-user e' l'utente di default sulle macchine RedHat, alla fine si mette il nome DNS pubblico o l'indirizzo pubblico)
Attenzione : si devono modificare i permessi del file .pem con chmod 400 AmazonEC2.pem


ssh -i AmazonEC2.pem ec2-user@xxxxxxxxxx.eu-west-3.compute.amazonaws.com

i comandi di root sono eseguiti usando sempre sudo. Una curiosita'...non c'e' la history sulla linea di comando di bash

Per la connessione con SFTP si puo' usare Filezilla impostandolo con l'accesso tramite File Chiave



Per connettersi in SSH da Putty si deve convertire la chiave in formato .pem in formato .ppk utilizzando PuttyGen e Load il file .pem e Save Private Key.
Il file nuovamente generato si inserisce in Connection\Auth e poi si stabilisce la connessione come di norma mettendo nell'host la combinazione ec2-user@xxxxxxxxxx.eu-west-3.compute.amazonaws.com



A questo punto si procede con la configurazione come di norma


sudo yum update
sudo yum install httpd
sudo apachectl start
sudo apachectl status
* httpd.service - The Apache HTTP Server
   Loaded: loaded (/usr/lib/systemd/system/httpd.service; enabled; vendor preset: disabled)
   Active: active (running) since Thu 2018-03-08 16:52:51 UTC; 57s ago
     Docs: man:httpd(8)
           man:apachectl(8)
 Main PID: 3406 (httpd)
   Status: "Total requests: 0; Current requests/sec: 0; Current traffic:   0 B/sec"
   CGroup: /system.slice/httpd.service
           |-3406 /usr/sbin/httpd -DFOREGROUND
           |-3407 /usr/sbin/httpd -DFOREGROUND
           |-3408 /usr/sbin/httpd -DFOREGROUND
           |-3409 /usr/sbin/httpd -DFOREGROUND
           |-3410 /usr/sbin/httpd -DFOREGROUND
           `-3411 /usr/sbin/httpd -DFOREGROUND

Una volta installato ed avviato il server http si deve aprire la porta 80 per l'accesso dall'esterno

ed alla fine il server httpd e' raggiungibile dall'esterno




per finire si deve rendere scrivibile dall'utente la directory del webserver per le modifiche

sudo usermod -a -G apache ec2-user
sudo chown -R ec2-user:apache /var/www
sudo chmod 2775 /var/www
find /var/www -type d -exec sudo chmod 2775 {} \;
find /var/www -type f -exec sudo chmod 0664 {} \;


attenzione : di default non e' abilitato il supporto https

mercoledì 7 marzo 2018

Mandelbrot con TensorFlow

Questo esempio del calcolo dell'insieme di Mandelbrot e' compreso all'interno del tutorial di TensorFlow. Lo scopo di questo post e' di capire come e' stato inserito il calcolo ricorsivo nella logica di TensorFlow tutta indirizzata all'utilizzo di matrici

Una osservazione : stranamente il calcolo e' molto lento. Credo che il problema sia dovuto alla logica con cui e' fatto il calcolo..invece di uscire dal ciclo di calcolo per ogni punto una volta che si e' raggiunta la soglia di fuga, con questo programma il calcolo viene rieffettuato su tutta la matrice per 200 volte



La logica: invece di effettuare il calcolo usando una matrice e a celle singole
-----------------------------
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
     
#MANDELBROT SET 520x600
# crea due array di 520x600 -1.3<X<1.3 -2<Y<1
# a passo 0.005
Y, X = np.mgrid[-1.3:1.3:0.005, -2:1:0.005]

#Crea una array di numeri complessi Z moltiplicando Y per sqrt(-1) (che in 
#in numpy e' j
Z = X+1j*Y

#trasforma l'array Z in un formato tensorflow
c = tf.constant(Z.astype("complex64"))

# popola la variabile zs con x
zs = tf.Variable(c)
# popola la variabile ns con tutti gli elementi a zero 
# e delle dimensioni di c, qui ci sara' il risultato del
# della divergenza
ns = tf.Variable(tf.zeros_like(c, "float32"))

#qui viene impiegata una sessione interattiva ma si puo' sostituire il comando con
# tf.Session()
# tanto non e' necessario il debug

sess = tf.InteractiveSession()
tf.initialize_all_variables().run()

# Compute the new values of z: z^2 + x
#zs_ e' una variabile transitoria su
#cui viene calcolata la ricorsione
zs_ = zs*zs + c

# se il modulo di zs e' minore di 4 
# salvalo nella matrice not_diverged
# nella matrice not_diverged viene salvato
# il valore boolean della condizione <4
# quindi nella matrice not_diverged ci sono 
# 0 ed 1
not_diverged = tf.abs(zs_) < 4

#tf.group raggruppa piu' operazioni
#copia la matrice transitoria zs_ su zs per continuare
# l'iterazione
# aggiunge poi alla matrice inizializzata  tutta a zeri (ns)
# il contenuto della matrice dei punti che non hanno fatto
#  modulo > 4. In questo modo viene creata una mappa
#di quanti cicli su ogni cella sono necessari
step = tf.group(
  zs.assign(zs_),
  ns.assign_add(tf.cast(not_diverged, "float32"))
  )

#200 cicli di iterazione della sessione
for i in range(200): step.run()

#mosta la matrice ns come immagine
plt.imshow(ns.eval())
plt.show()

Vacanze sul Sole

E dopo aver prenotato un posto sulla missione Insight per Marte adesso destinazione Sole con Parker Solar Probe .. devo informarmi un po' sulle date di partenza o se c'e' un taxi tra il Sole e Marte





domenica 4 marzo 2018

Supervised Classification USGS Spectral Library

Dopo aver letto le note introduttive di TensorFlow (l'insieme di librerie di Machine Learning di Google) ed in particolar modo l'esempio sulla classificazione degli Iris sulla base di elementi morfologici mi e' venuta la domanda se il metodo era applicabile anche al telerilevamento iperspettrale, oggetto della mia tesi di dottorato.

Il problema a questo punto era prima di tutto trovare una base dati di training il piu' possibile popolata di elementi (in dottorato ho fatto collezione di spettri ma non organizzate in modo tale da essere utili allo scopo) e la scelta e' caduta su USGS Spectral Libray (gia' usata qui) in particolare per la sezione degli spettri del satellite Hyperion, oramai dismesso ma che e' stato anche lui oggetto di parte della tesi

Visto che a lavoro mi sto occupando in questi di minerali della famiglia dell'asbesto (http://debiaonoldcomputers.blogspot.it/2018/02/actinolite-e-tremolite-ad-impruneta.html) ho provato ad estrarre gli spettri di actinolite, tremolite e serpentino.
In totale il dataset, costituito dalle 3 classi, e' da 23 campioni da 234 bande (nel database gli spettri sono in numero maggiore ma sono stati scelti solo quelli che avevano un campionamento omogeneo)

Gli spettri sono stati tutti normalizzati prima di entrare nel file del dataset.
Si poteva a questo punto si fare l'analisi con le sole componenti principali (PCA analysis) per rendere il dataset piu' piccolo eliminando tutti i dati autocorrelati oppure dare in pasto all'algoritmo tutto lo spettro; ho provato con la seconda strada per vedere come si comportava il codice di calcolo

Nel dettaglio sono stati scelti

Actinolite
s07HYPRN_Actinolite_HS22.1B_ASDFRb_AREF
s07HYPRN_Actinolite_HS22.2B_ASDFRb_AREF
s07HYPRN_Actinolite_HS22.3B_ASDFRb_AREF
s07HYPRN_Actinolite_HS22.4B_ASDFRb_AREF
s07HYPRN_Actinolite_HS116.1B_ASDFRb_AREF
s07HYPRN_Actinolite_HS116.2B_ASDFRb_AREF
s07HYPRN_Actinolite_HS116.3B_ASDFRb_AREF
s07HYPRN_Actinolite_HS116.4B_ASDFRb_AREF
s07HYPRN_Actinolite_HS315.1B_ASDFRb_AREF
s07HYPRN_Actinolite_HS315.2B_ASDFRb_AREF

Tremolite

s07HYPRN_Tremolite_HS18.1B_ASDFRc_AREF
s07HYPRN_Tremolite_HS18.2B_ASDFRc_AREF
s07HYPRN_Tremolite_HS18.3_BECKc_AREF
s07HYPRN_Tremolite_HS18.3B_ASDFRc_AREF
s07HYPRN_Tremolite_HS18.3B_NIC4ccc_RREF
s07HYPRN_Tremolite_HS18.4B_ASDFRc_AREF
s07HYPRN_Tremolite_NMNH117611.HCl_BECKb_AREF
s07HYPRN_Tremolite_NMNH117611.HCL_NIC4bb_RREF

Serpentino
s07HYPRN_Serpentine_HS8.2B_ASDFRc_AREF
s07HYPRN_Serpentine_HS8.3B_ASDFRc_AREF
s07HYPRN_Serpentine_HS8.3B_BECKc_AREF
s07HYPRN_Serpentine_HS8.4B_ASDFRc_AREF
s07HYPRN_Serpentine_HS8.6_ASDFRc_AREF
s07HYPRN_Serpentine_HS318.1B_ASDFRc_AREF
s07HYPRN_Serpentine_HS318.2B_ASDFRc_AREF
s07HYPRN_Serpentine_HS318.3B_ASDFRc_AREF
s07HYPRN_Serpentine_HS318.4B_ASDFRc_AREF
s07HYPRN_Serpentine_HS318.4B_BECKc_AREF
s07HYPRN_Serpentine_HS318.6_ASDFRc_AREF



Ho provato ad usare TensorFlow per il calcolo ma mi e' decisamente ostico. Ho trovato che l'analisi del dataset Iris era stato trattato in questo post trattato con la libreria SkLearn,  con associate le librerie esterne Pandas e NumPy. I data sono tutti contenuti in un file, sia il training che il test dataset; il dataset sara' diviso in due dalla funzione train_test_split (in questo caso su 23 campioni viene scelto il 20% dei dati come parte di test del modello)

La prima riga del file all_data.txt e' costituito da un header con i nome delle 234 bande e un campo finale del nome (quindi la tabella e' di 235x24 celle)

-----------------------------------------
import pandas as pd
import numpy as np

dataset = pd.read_csv("all_data.txt")

X = dataset.iloc[:,:233].values
y = dataset['classe'].values

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = 82)

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

# Fitting Multiclass Logistic Classification to the Training set
from sklearn.linear_model import LogisticRegression

logisticregression = LogisticRegression()
logisticregression.fit(X_train, y_train)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
verbose=0, warm_start=False)

# Predicting the Test set results
y_pred = logisticregression.predict(X_test)
print(y_pred)

#lets see the actual and predicted value side by side
y_compare = np.vstack((y_test,y_pred)).T

#actual value on the left side and predicted value on the right hand side
#printing the top 5 values
y_compare[:5,:]

# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print(cm)

#finding accuracy from the confusion matrix.
a = cm.shape
corrPred = 0
falsePred = 0

for row in range(a[0]):
for c in range(a[1]):
if row == c:
corrPred +=cm[row,c]
else:
falsePred += cm[row,c]
print('Correct predictions: ', corrPred)
print('False predictions', falsePred)
print ('Accuracy of the multiclass logistic classification is: ', corrPred/(cm.sum()))
------------------------------

Il risultato finale e' seguente

[[2 0 0]
 [0 2 0]
 [0 0 1]]
('Correct predictions: ', 5)
('False predictions', 0)

('Accuracy of the multiclass logistic classification is: ', 1)


Per prova ho deliberatamente messo nel test dataset uno spettro con una classificazione sbagliata. Il risultato e' che l'algoritmo mi ha riportato un errore di classificazione...quindi direi che funziona

Il dataset e' sicuramente modesto e si possono fare miglioramenti ma direi che lo scopo e' stato raggiunto. La cosa interessante sarebbe ripetere questa esperienza con TensorFlow









venerdì 2 marzo 2018

Evadere da un proxy server (definitivo)

Tempo fa (un bel po') avevo provato ad aprire una sessione SSH attraverso il proxy aziendale fallendo miseramente



Adesso mi sono rimesso a studiare il problema con un po' piu' di attenzione.
Con poca fatica ho scoperto che il prxy aziendale e' uno Squid che di default tiene aperte queste porte


L'intuizione di usare la porta 443 per configurare un server SSH esterno come ponte era giusta ma mancavano un po' di dettagli. 
Prima di tutto ho scoperto che un server SSH su Linux puo' essere messo in ascolto su piu' porte..basta aggiungere nella configurazione del demone SSHD /etc/ssh/sshd_config una porta aggiuntiva alla 22 (altrimenti tutti gli altri servizi gia' attivi li perdevo) ovvero la 443

Port 22
Port 443

si ricarica la configurazione ed il server SSH risponde alle due porte (ovviamente il web server non ha la necessita' di https)

la macchina di ufficio e' un Windows e di solito uso Putty. Si deve configurare oltre alla connessione anche il proxy spuntando HTTP ed inserendo IP e porta del proxy



e come direbbe Joe Dalton ... LIBERO!!


Pulizie di (quasi) primavera

Regola numero 1: non tenere bottiglie aperte sulla scrivania del lavoro specialmente quando hai il portatile

Regola numero 2 : non mangiare alla scrivania di lavoro, specialmente cose che si sbriciolano


Regola numero 3 : ricordati di fare pulizia periodica della tastiera

Forse devo fare pulizia

Piu' nel dettaglio
Regola numero 4 : NON PERDERE I TASTI !! (li devi rimontare)