Goering ed il "porcellino"

Stavo guardando un documentario su Hermann Goring e da fiorentino non ho potuto fare a meno di notare la statua del Porcellino di Pietro Tacca presente in una delle residenze di Goring

Fotogramma del documentario

Con un po' di ricerca ho trovato che la statua si trovava nella residenza estiva a Carinhall. Non sono riuscito a trovare notizie se la statua presso Carinhall sia una copia (ne esistono tuttora molte a giro per il mondo) o, visto il vizio di Goring di portarsi a casa cio' che ci piaceva, dell'originale (attualmente a Firenze al Museo Bardini)

Originale (Wikipedia)

Tributo a Gilles

Per lavoro capita spesso di effettuare sopralluoghi in fabbriche dismesse e trovare ricordi di epoche passate. Non poteva passare inosservato questo poster allegato alla rivista CorrierBoy del 2 maggio 1979 appeso ad un muro

...e no, non era possibile staccarlo e verra' presto rimosso dai lavori di ristrutturazione
Frugando su Internet e' comparsa una immagine di qualita' migliore

ConnManCtl Command line network manager

Cercando di mettere su una macchina dalle risorse ridotte ho installato una Debian netinst con I3
Per ridurre il carico volevo un network manager da linea di comando ed ho trovato connmanctl

per utilizzarlo si digita connmanctl e si apre un prompt

enable wifi
scan wifi
services
agent on
connect (si deve copiare la stringa accanto al nome del proprio AP vedi immagine)

Nell'uso mi sono accorto che il DNS non viene gestito dal DHCP ma viene preso quello inserito in resolv.conf

Una volta connessi ad una rete wifi al successivo riavvio non e' necessario ripetere la procedura di autenticazione

OpenCV Houghes Circles and Gui test

===============================================
import cv2
import numpy as np

alpha_slider_max = 20
title_window = 'Conteggio eventi'

def on_trackbar(val):
    #img = originale.copy()
    #cv2.rectangle(img,(0,0),(100,100),(255,255,255),-1)
    
    t1 = cv2.getTrackbarPos(trackbar_name, title_window)
    t2 = cv2.getTrackbarPos(trackbar_name_2, title_window)
    t3 = cv2.getTrackbarPos(trackbar_name_3, title_window)

    par1 = cv2.getTrackbarPos(trackbar_name_4, title_window)
    par2 = cv2.getTrackbarPos(trackbar_name_5, title_window)

    #print(str(t1))
    #print(str(t2))
    #contrasto
    img = originale.copy()
    contrast = t3
    f = 131*(contrast+127)/(127*(131-contrast))
    alpha_c = f
    gamma_c = 127*(1-f)
    img_con = cv2.addWeighted(img,alpha_c,img,0,gamma_c)
    #img_con = f*(img)+127*(1-f)
    cv2.imshow("contrasto",img_con)

    #img=originale.copy()
    gray = cv2.cvtColor(img_con, cv2.COLOR_BGR2GRAY)
    img_blur = cv2.medianBlur(gray, 5)
    circles = cv2.HoughCircles(img_blur, cv2.HOUGH_GRADIENT, 1, img.shape[0]/64, param1=par1, param2=par2, minRadius=t1+1, maxRadius=t2+1)
    conta = 0
    if circles is not None:
    circles = np.uint16(np.around(circles))
    for i in circles[0, :]:
conta=conta+1
        cv2.circle(img_con, (i[0], i[1]), 2, (0, 0, 255), 2)

    font = cv2.FONT_HERSHEY_SIMPLEX
    cv2.putText(img, "{:.0f}".format(conta) ,(10,15), font, 0.5,(255,0,0),2,1)
    cv2.imshow(title_window,img_con)
    #print ("Numero identificazioni :"+str(conta))
    #print(str(val))

global originale

originale = cv2.imread('cr39film.png', cv2.IMREAD_COLOR)
gray = cv2.cvtColor(originale, cv2.COLOR_BGR2GRAY)


cv2.namedWindow(title_window)
trackbar_name = 'MinRadius x %d' % alpha_slider_max
trackbar_name_2 = 'MaxRadius x %d' % alpha_slider_max
trackbar_name_3 = 'Contrasto x %d' % 127

trackbar_name_4 = 'Par 1 x %d' % alpha_slider_max
trackbar_name_5 = 'Par 2 x %d' % alpha_slider_max


cv2.createTrackbar(trackbar_name_2, title_window , 5, alpha_slider_max, on_trackbar)
cv2.createTrackbar(trackbar_name, title_window , 1, alpha_slider_max, on_trackbar)
cv2.createTrackbar(trackbar_name_3, title_window , 1, 127, on_trackbar)
cv2.createTrackbar(trackbar_name_4, title_window , 1, 50, on_trackbar)
cv2.createTrackbar(trackbar_name_5, title_window , 1, 5, on_trackbar)


on_trackbar(5)
cv2.waitKey()
cv2.destroyAllWindows()

Enigma

Leggendo di Enigma mi e' venuta la voglia di provar a scrivere una versione in Python..rendendomi conto che non e' proprio banale

La prima  cosa che ho imparato a mie spese e' che si deve progettare tutto in modo simmetrico perche' la codifica e la successiva decodifica avvengono con le stesse impostazione

In un primo momento avevo usato un array per simulare un rotore ma lo avevo creato inserendo dei valori a caso. Invece per permettere che la decodifica segua lo stesso percorso (all'inverso della codifica) l'array non puo' essere creato a caso ma le posizioni devono essere reciproche...meglio con un esempio...se la posizione  5 dell'array contiene un valore 13 la posizione 13 deve contenere il vaore 5

================================================================================
import numpy as np
import readchar
#                        a  b  c  d  e  f  g  h  i j   k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z
#                        0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 
plugboard   = np.array([16,21,11,15,18,25, 9,22,14, 6,20, 2,13,12, 8, 3, 0,23, 4,24,10, 1, 7,17,19, 5])
rotore_1    = np.array([ 6,10,16,25,20,18, 0,23,17,11, 1, 9,15,19,24,12, 2, 8, 5,13, 4,22,21, 7,14, 3])
rotore_2    = np.array([25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
rotore_3    = np.array([17,22,25, 8,16,20,19,14, 3,23,12,24,10,18, 7,21, 4, 0,13, 6, 5,15, 1, 9,11, 2])
riflettore  = np.array([24, 5,11,16,21, 1,25,23,10,22, 8, 2,13,12,18,20, 3,19,14,17,15, 4, 9, 7, 0, 6])

while True:
    c = readchar.readkey()
    print(c), 
    print(ord(c)-97),
    pg = plugboard[ord(c)-97]
    print("PG "+str(pg)),
    r1 = rotore_1[pg]
    print("/R1 "+str(r1)),
    r2 = rotore_2[r1]
    print("/R2 "+str(r2)),
    r3 = rotore_3[r2]
    print("/R3 "+str(r3)),
    ri = riflettore[r3]
    ri_2 = riflettore[ri]
    print("/RI "+str(ri)),
    print("/RI2 "+str(ri_2)),
    r3 = rotore_3[ri_2]
    print("/R3 "+str(r3)),
    r2 = rotore_2[r3]
    print("/R2 "+str(r2)),
    r1 = rotore_1[r2]
================================================================================

Questa e' la base con tutti i passaggi nei rotori, nella plugboard e nel riflettore
Il problema e' che il dopo il primo passaggio il primo rotore esegue una rotazione per cambiare in automatico il percorso di criptazione ma al momento non sono riuscito ad utilizzare in modo semplice la rotazione dell'array

Dumpster Diving Samsung GT-S5280

E' abbastanza incredibile cosa si trovi nella raccolta differenziata delle batterie. Questa volta e' toccato ad un Samsung GT-S5280 (a cui per ironia della sorte avevano tolto proprio la batteria oltre alla Sim Card ed alla SD Card...falla a capire la logica delle persone)

Ovviamente e' partita la sfida a rimetterlo in vita.

All'accensione era presente un pattern lock....ho provato a  fare un po' di tentativi di sblocco a caso ma senza successo. Non volevo resettarlo perche' ero curioso di vedere in che condizioni era il telefono (ovviamente non era mio interesse accedere ad account privati o foto...le avrei rimosse senza guardarle). Ho provato a cliccare su Forgot Pattern ma questa opzione mi ha portato alla richiesta di Pin ... vallo ad indovinare...1234...No....0000... Entrato, troppo facile.

Alla fine il precedente proprietario aveva fatto un Factory Reset (ma allora perche' mettere il Pattern Lock?) ma in ogni caso il telefon e' perfettamente funzionante e si e' aggiornato per diverse volte (Samsung ha ancora sui server gli aggiornamenti per un telefono  del 2013!)

Conteggio automatico film radon con OpenCV

Per lavoro puo' essere che puo' essere che mi trovi a dover contare delle lastre dei rilevatori di radon e volevo provare a fare qualcosa di mio con OpenCV. Per prova ho preso delle immagini da Google Images e le ho trattate con OpenCV e gli Hough Circles

Immagine non elaborata

link

Immagine non elaborata con sovrapposizione del riconoscimento e del numero degli eventi

Elabotazione Conteggio 126 eventi

questo e' il file Python che e' preso dagli esempi di OpenCV con minime modifiche
=======================================================
import cv2
import numpy as np
# Read image as gray-scale
img = cv2.imread('cr39film.png', cv2.IMREAD_COLOR)
cv2.imshow('Originale',img)

# Convert to gray-scale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Blur the image to reduce noise
img_blur = cv2.medianBlur(gray, 5)
# Apply hough transform on the image
circles = cv2.HoughCircles(img_blur, cv2.HOUGH_GRADIENT, 1, img.shape[0]/32, param1=50, param2=5, minRadius=0, maxRadius=10)
conta = 0
# Draw detected circles
if circles is not None:
    circles = np.uint16(np.around(circles))
    for i in circles[0, :]:
        # Draw outer circle
        #cv2.circle(img, (i[0], i[1]), i[2], (0, 255, 0), 2)
        # Draw inner circle
conta=conta+1
        cv2.circle(img, (i[0], i[1]), 2, (0, 0, 255), 2)

print ("Numero identificazioni :"+str(conta))
cv2.imshow('tt',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
=======================================================

link

Elaborazione Conteggio 175 eventi

diciamo che nonostante  il poco tempo dedicato al problema i risultati non sono niente male