Ansiktsigenkänningsspegel med hemligt fack: 15 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:37

Jag har alltid fascinerats av de ständigt kreativa hemliga facken som används i berättelser, filmer och liknande. Så när jag såg den hemliga tävlingen bestämde jag mig för att experimentera med idén själv och göra en vanlig spegel som öppnar en hemlig sidolåda när rätt person tittar in i den.

Genom att använda en Raspberry Pi, viss kunskap om pythonprogrammering och butiksklass i åttonde klass, kan vi skapa denna spiffiga enhet för att dölja föremål i synhåll som bara rätt användare har tillgång till.

Jag vill rikta ett särskilt tack till dessa personer/plattformar där jag också fick min information och resurser:

TeCoEd - Youtube -kanal

Emmet från PiMyLifeUp

MJRoBot på Hackster.io (profil)

Gaven MacDonald - Youtube -kanal

Tucker Shannon on Thingiverse (profil)

Tillbehör

Ramtillbehör:

• Träplanka (måtten på denna bräda var 42 x 7,5 tum med 5/16 tum)
• Penna bildram (med glas)
• Sprayfärg
• Envägsreflekterande lim
• Glasrengöring & trasa
• MDF Trä

Ansiktsigenkänningstillbehör:

• Raspberry Pi (jag använde Pi 3 B+ men det finns andra alternativ)
• Kameramodul
• Stegmotor

Verktyg:

• Bordsåg
• Jigsåg
• Sandpapper Trä
• LimTape
• Mäta
• Sax
• Sprayflaska
• 3d skrivare
• Superlim

Steg 1: Klipp för boxramen

Jag köpte en bildram från second hand-butiken. Bara en varning, se till att plankorna i ramen är minst 1 1/2 breda. Detta är så att du kan limma andra träskivor på det med tillräckligt med utrymme att arbeta med. Se också till att glaset i ramen är helt klar. Jag köpte en frostad av en slump och fick sedan köpa en annan ram bara för det klara glaset. Eftersom min ram används kan måtten på lådramen variera.

• Lägg ramen i stående orientering. Mät långsidorna (LS) på glashålssidan på ramen med ytterligare ½”på både ovansidan och botten. (dvs lägg till en tum på långsidan av glashålsmätningen. Anteckna detta och märk LSM (Long Side Measurement).
• På samma sätt mäter du hålets ovansida och lägger till ytterligare 1 ". Anteckna detta och märk SSM (Short Side Measurement).
• Skaffa din bräda och skär med en bordssåg två LSM x 2”och två SSM x 2”.
• Ta en av LSM -skärningarna och mät en 2 "x1" rektangel som är 1 "från botten och ½" från vänster och höger sida (som visas på bild 3).
• Skär ut hålet med en sticksåg. Slipa sedan ut kanterna med sandpapper.

Steg 2: Skär för lådan

Nu ska vi börja bygga lådan (alias ett hemligt fack).

• Klipp ut två 4 "x 1" sidor, en 3 "x 1" (bakkant), en 4 "x 1" (framkant) och en 4 "x 3" (plattform).
• Limma den första 4 "x 1" sidan längs den 4 "sidan av plattformen. Jag lade ett par vikta papper under plattformssidan så att det lyftes något, på så sätt skulle det inte slita på hålet som jag skar ut i LS -plankan. Låt torka i 30 minuter.
• Limma på samma sätt 3 "x 1" längs plattformens 3 "" kant. Låt torka i 30 minuter. Limma sedan den andra 4”x 1” sidan på motsatta sidan av den första. Låt torka i 30 minuter.
• Lägg undan framkanten för tillfället. Det blir det sista som limmas på lådan.
• När du är klar kontrollerar du om den passar in i hålet du pusslade in i LSM -plankan. Om inte, slipa hålet tills lådan lätt glider in och ut, och det finns ingen dragning.

Steg 3: Sätta ihop ramen

Med alla delar färdiga kan vi börja montera hela ramen.

• Limma LSM -plankan centrerad med glashålet med en ½”på varje sida. Se till att den är limmad med ½”från hålet (som visas på bild 1). Låt torka i 30 minuter.
• Limma den första SSM -plankan med kanten som rör vid insidan av LSM -plankan som just limmades. (Använd en linjal för att se till att den är limmad på rak). Låt torka i 30 minuter.
• Ta den andra LSM -sidan och limma liknande den första. Se till att det är ½”från hålet och att SSM som precis fästs är limmad på insidan av plankan. Låt torka i 30 minuter.
• Limma den sista SSM på överkanten. Eftersom du har två LSM på båda sidor, beroende på hur rakt du fäster dem, kan du behöva slipa SSM -sidorna för att se till att det passar (min skärning är ibland avstängd). Låt torka i 30 minuter.
• Mät det lilla utrymmet mellan lådans botten och ramen. Skär en bit MDF -trä med denna mått, med 4 ". Du vill göra denna bit nära lådan men inte vidröra den. Den är avsedd att stödja lådan med minimal friktion.
• När allt var klart spraymålade jag ramen så att alla bitar matchade.

Steg 4: För spegeln

Envägsfilmen som jag köpte av Amazon var cirka $ 10. Det finns sådana av bättre kvalitet som är lite dyrare om du är intresserad. Den jag använder reflekterar men du kan se att det inte är en vanlig spegel som du skulle se i ett hem. De dyrare får dig det utseendet.

• Rengör glaset med glasrenare på båda sidor.
• Rulla ut envägslimet och lägg glaset ovanpå. Klipp ut limmet så att det finns minst ½”överskott på varje sida av glaset.
• Lägg glaset åt sidan och blöt ena sidan av det med vatten. Skala sedan av plastskiktet av envägslimet och spraya den nyblottade sidan med vatten.
• Placera glasets våta sida på limmets våta sida. Låt sitta i 30 minuter.
• Vänd och använd tummen för att platta ut eventuella bubblor mellan limmet och glaset. Skär sedan överflödigt lim från kanterna.

Steg 5: Installera Raspbian Stretch

Detta var min första gång som jag fördjupade mig i Raspberry Pi -miljön och jag började leta efter instruktioner om hur man installerar operativsystemet. Jag hittade så småningom en enkel tutorial på Youtube av TeCoEd som gick igenom processen att få Stretch installerat på SD -kortet (med en ganska härlig introduktion också). Här är länken till självstudien:

I huvudsak är allt du behöver göra:

• Formatera SD -kortet genom att välja ditt Drive >> Drive Tools >> Format. Ladda ner ZIP-filen för Raspian Stretch (finns här:
• Flasha OS -bilden till SD -kortet. TeCoEd använde Win32 Disk Imager för att slutföra detta. Jag slutade installera balenaEtcher som verkade lite mer enkelt. (Här är nedladdningslänken för balenaEtcher:
• Väl i balenaEtcher väljer du "Flash From File" och väljer den tidigare nedladdade ZIP -filen. Välj sedan önskat SD -kort (om det inte väljs automatiskt). Tryck sedan på den saftiga blixtknappen och vänta på att magin ska hända.

När du har installerat det på SD -kortet kan du sätta in det i Raspberry Pi och gå igenom den allmänna Pi -installationsprocessen.

Steg 6: Installera OpenCV

Nu till de mer ansiktsigenkänningsorienterade delarna. För att känna igen ansikten måste vi ladda ner OpenCV -biblioteket som innehåller ett stort antal verktyg för att arbeta med datorsyn.

Att installera OpenCV var den jobbigaste delen av programvaruaspekten för mig. Men efter att ha följt många instruktioner hittade jag äntligen en handledning av Emmet från PiMyLifeUp som gjorde susen som finns här:

Jag kommer inte att gå igenom dessa steg eftersom du kommer att vara bättre lämpad att följa dem från länken (med de givna förklaringarna och möjligheten att kopiera och klistra in direkt från webbplatsen med lätthet).

Steg 7: Aktivera/testa kameran

Efter att ha installerat OpenCV slutfördes resten av min resa med en handledning av MJRoBot på Hackster.io som finns här:

Innan vi sätter igång vill jag påminna dig om att jag inte är den ursprungliga skaparen av dessa skript men ändrade delar av dem.

Till att börja med bör vi testa kameran för att se till att vi kan fånga video på skärmen. Jag tillbringade ungefär en timme med att försöka köra skriptet i steg 3 i MJRoBot. Som livet skulle ha det måste vi faktiskt aktivera kameran på Raspberry Pi (det visar sig att det kan vara en bra idé att läsa instruktionerna … mmm nah). Så följ kameran efter att du har anslutit kameran till dess korrekta port:

• Öppna en kommandoterminal och skriv sudo raspi-config
• Välj "Aktivera kamera" (detta kan hittas under ett enhetsalternativ)
• Tryck på "Enter"
• Gå till "Slutför" och du kommer att bli ombedd att starta om

Följ sedan dessa steg:

• Gå till hallonens huvudmeny (uppe till vänster)
• Preferenser
• Raspberry Pi -konfiguration
• Gränssnitt
• Välj sedan "Enabled" i Kamera
• Sedan "OK"

Nu borde du kunna köra detta skript framgångsrikt från MJRoBots handledning för att testa kameran (kom ihåg att all denna kod plus en mer ingående beskrivning finns i länken ovan till MJRobots handledning):

importera numpy som np

import cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Height while (True): ret, frame = cap.read () frame = cv2. vänd (ram, -1) # Vänd kamera vertikalt grå = cv2.cvtColor (ram, cv2. COLOR_BGR2GRAY) cv2.imshow ('ram', ram) cv2.imshow ('grå', grå) k = cv2.waitKey (30) & 0xff om k == 27: # tryck på 'ESC' för att avsluta break cap.release () cv2.destroyAllWindows ()

Den föregående koden ska visa två fönster, ett i färg och det andra i gråskala. Om du lyckades så långt tycker jag att du förtjänar en god smörgås.

Steg 8: Samla in data och utbildningsdata

I den medföljande självstudien går författaren in på ett mycket mer djupgående om kodens processer som snart kommer att tillhandahållas, men eftersom det här är instruktioner om hur denna spegel gjordes kommer jag inte att fördjupa mig i historien eller den komplicerade mekaniken. Jag rekommenderar dig dock att ta en månad av ditt liv att läsa om dessa två saker eftersom de kan tjäna ditt sinne väl.

Det finns bara ytterligare tre skript att köra innan vi kan få allt att fungera. Det första är för att samla in data, det andra är för att träna det och det sista är faktiskt för erkännande. Insamling av data kräver att verkliga bilder av ansiktet tas och förvaras på en specifik plats för träning. Skaparen av denna kod gjorde det väldigt enkelt att få allt detta gjort så jag rekommenderar att du följer dessa instruktioner för att undvika huvudvärk.

Öppna en kommandorad och skapa en ny katalog som heter den något roligt (jag kallade min FaceRec)

mkdir FaceRec

Ändra nu katalogen till FaceRec och gör en underkatalog som är säker på att namnge den dataset

cd FaceRec

mkdir dataset

Medan vi håller på kan vi också göra den andra underkatalogen som heter tränare

mkdir tränare

Nu kan du köra och följa anvisningarna i det första skriptet som tar bilder av en användare. (Bara en uppmärksamhet, se till att ange användar -id som antingen 1, 2, 3 etc.)

import cv2import os cam = cv2. VideoCapture (0) cam.set (3, 640) # set video width cam.set (4, 480) # set video height face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # För varje person, ange ett numeriskt ansikts -ID face_id = input ('\ n ange användar -ID, slut tryck ==>') utskrift ("\ n [INFO] Initierar ansiktsinspelning. Titta på kameran och vänta …") # Initiera enskilt provtagningsantal ansikte count = 0 while (True): ret, img = cam.read () img = cv2.flip (img, -1) # vänd videobild vertikalt grå = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) ansikten = face_detector.detectMultiScale (grå, 1,3, 5) för (x, y, w, h) i ansikten: cv2.rektangel (img, (x, y), (x+w, y+h), (255, 0, 0), 2) count + = 1 # Spara den tagna bilden i datamängden mappen cv2.imwrite ("dataset/User." + Str (face_id) + '.' + Str (count) + ".jpg", grå [y: y +h, x: x+w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # Tryck på 'ESC' för att avsluta video om k == 27: bryt elif count> = 30: # Ta 30 ansiktsprov och stoppa videobrottet k print ("\ n [INFO] Avsluta program och sanering") cam.release () cv2.destroyAllWindows ()

Se till att du har installerat kudde på Pi nu. Om inte, kör kommandot:

pip installera kudden

När det är klart kan du köra träningsskriptet (andra skriptet) som sömlöst kommer att ge dig en.yaml -fil som kommer att användas i det sista skriptet

importera cv2import numpy som np från PIL import Bildimport os # Sökväg för ansiktsbilddatabas sökväg = 'dataset' igenkänare = cv2.face. LBPHFaceRecognizer_create () detektor = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # funktion för att hämta bilderna och märka data def getImagesAndLabels (sökväg): imagePaths = [os.path.join (sökväg, f) för f i os.listdir (sökväg)] faceSamples = ids = för imagePath i imagePaths: PIL_img = Image.open (imagePath).convert ('L') # konvertera den till gråskala img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. split (".") [1]) ansikten = detector.detectMultiScale (img_numpy) för (x, y, w, h) i ansikten: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Träningsytor. Det tar några sekunder. Vänta …") ansikten, ids = getImagesAndLabels (sökväg) identifierer.train (ansikten, np.array (ids)) # Spara modellen i tränare/trainer.yml igenkännare.skriv ('tränare/tränare.yml') # igenkännare.spara () fungerade på Mac, men inte på Pi # Skriv ut antalet utbildade ansikten och avsluta programutskrift ("\ n [INFO] {0} utbildade ansikten. Avslutar program".format (len (np.unique (ids))))

Det som är coolt med den här uppsättningen skript är att flera ansikten kan matas in i systemet, vilket innebär att flera individer kan komma åt spegelns inre om så önskas.

Nedanför har jag Data Capture script och Training script tillgängligt för nedladdning.

Steg 9: Ansiktsigenkänningstid

Slutligen kan vi köra igenkänningsskriptet. Mer kod lades till i detta skript för att göra motorprocessen funktionell så jag ska förklara dessa delar lite mer grundligt. Jag delar upp det i sektioner men jag lägger hela manuset i slutet av steget om det är det du är ute efter.

Vi börjar med att importera alla moduler vi behöver och ställer sedan in GPIO -läget till GPIO. BCM

importera numpy som np

import os importtid import RPi. GPIO som GPIO GPIO.setwarnings (False) GPIO.setmode (GPIO. BCM)

Denna nästa lista med namnet ControlPin är en rad nummer som representerar utgångsstiften som kommer att användas för vår stegmotor.

ControlPin = [14, 15, 18, 23]

Förslingan ställer in dessa stift som utgångar och ser sedan till att de är avstängda. Jag har fortfarande lite kod här för att låta lådan stänga med ett knapptryck men jag bestämde mig för att använda en timer istället.

GPIO.setup (ControlPin , GPIO. OUT)

GPIO.output (ControlPin , 0) GPIO.setup (2, GPIO. IN, pull_up_down = GPIO. PUD_DOWN)

De två följande variablerna är sekvenser vi kommer att använda för att driva motorn. Jag lärde mig denna information från en underbar video av Gaven MacDonald som jag starkt rekommenderar att titta på när han fördjupar sig inte bara i koden utan själva motorn (finns här: https://www.youtube.com/embed/Dc16mKFA7Fo). I huvudsak kommer varje sekvens att itereras genom att använda de kapslade for-looparna i de kommande openComp- och closeComp-funktionerna. Om du tittar noga är seq2 precis raka motsatsen till seq1. Japp, du gissade det. Den ena är för att flytta motorn framåt och den andra är för bakåt.

seq1 =

seq2 =

Från och med vår openComp-funktion skapar vi en for-loop som kommer att upprepas 1024 gånger. Enligt MacDonalds video skulle 512 iterationer ge en full rotation av motorn och jag fann att cirka två varv var en bra längd men detta kan justeras beroende på individens storlek. Nästa for-loop består av 8 iterationer för att ta hänsyn till de 8 arrays som finns i seq1 och seq2. Och slutligen, den sista for-loop-repetiten upprepas fyra gånger för de fyra objekten som finns i var och en av dessa matriser samt de 4 GPIO-stiften som vi har vår motor ansluten till. Linjen här nedan väljer GPIO -stiftet och slår sedan på det antingen på eller av beroende på vilken iteration det är på. Linjen efter ger en viss bufferttid så att vår motor inte roterar alls. När motorn roterar för att flytta ut lådan sover den i 5 sekunder innan den går vidare. Denna tid kan justeras här eller så kan du aktivera den kommenterade koden som gör det möjligt att använda en tryckknapp för att vidarebefordra med skriptet snarare än en timer.

för i inom räckvidd (1024):

för halvsteg i intervallet (8): för stift i intervall (4): GPIO.output (ControlPin [pin], seq1 [halfstep] [pin]) time.sleep (.001) '' 'medan True: if GPIO.input (2) == GPIO. LOW: break; '' 'time.sleep (5)

CloseComp -funktionen fungerar på ett liknande sätt. Efter att motorn har flyttat tillbaka fortsätter jag med att ställa in våra sista GPIO -stift till lågt för att se till att vi inte slösar bort energi och sedan lägger jag till ytterligare tre sekunder innan jag går vidare.

för i inom räckvidd (1024):

för halvsteg i intervallet (8): för stift i område (4): GPIO.output (ControlPin [pin], seq2 [halfstep] [pin]) time.sleep (.001) print ("Fack stängt") GPIO.output (ControlPin [0], 0) GPIO.output (ControlPin [3], 0) time.sleep (3)

Huvuddelen av nästa del används för att ställa in kameran och börja ansiktsigenkänning. Återigen går MKRoBots instruktioner mer in i delarna men för tillfället visar jag bara delarna som används för spegeln.

Först ändrade jag listnamnen så att mitt namn är i indexet som jag tilldelade det medan jag samlade in data (i mitt fall 1). Och sedan ställde jag in resten av värdena till None eftersom jag inte hade fler ansikten i datasetet.

names = ['None', 'Daniel', 'None', 'None', 'None', 'None']

Våra sista kodrader implementeras i thicc for-loop. Jag skapade en variabel för att lagra förtroendet som ett heltal (intConfidence) innan variabelns förtroende blir till en sträng. Sedan använder jag en if-sats för att kontrollera om förtroendet är större än 30 och om id (vilken person datorn upptäcker, i det här fallet”Daniel”) är lika med mitt namn. Efter att detta har bekräftats kallas funktionen openComp som (som förklarat tidigare) rör motorn, sparkar ut efter 5 sekunder och fortsätter sedan att stängaComp som flyttar motorn i motsatt riktning och gör en del rengöring innan du fortsätter med thicc -slingan.

om intConfidence> 30 och id == 'Daniel':

openComp () closeComp ()

Ett fel som jag hittade här är att koden fortsätter ibland när closeComp återvänder, men det villkorade if-statementet visar sig vara sant igen som om det läser videoflöde som fortfarande finns i bufferten. Även om det inte händer varje gång jag ännu har hittat ett sätt att se till att det aldrig händer, så om någon har några idéer, låt mig bara veta i kommentarerna.

Här är hela skriptet på ett och samma ställe (och strax nedanför är det nedladdningsbart):

importera cv2

import numpy som np import os importtid import RPi. GPIO som GPIO GPIO.setwarnings (False) GPIO.setmode (GPIO. BCM) ControlPin = [14, 15, 18, 23] för i i intervall (4): GPIO.setup (ControlPin , GPIO. OUT) GPIO.output (ControlPin , 0) GPIO.setup (2, GPIO. IN, pull_up_down = GPIO. PUD_DOWN) seq1 =

Steg 10: Montering av Pi och anslutning av motorn

Att montera Raspberry Pi på ramen var ganska enkelt. Jag konstruerade en liten 90-graders armbåge med ena ansiktet med ett hål och den andra sidan var helt platt. Efter 3D -utskrift av två av dessa kan de fästas med skruvar på Raspberry Pi på dess monteringshål (jag använde de två hålen på varje sida av GPIO -stiften).

Jag fortsatte sedan med att använda superlim på de motsatta sidorna av de 3D -tryckta armbågarna för att limma Pi strax ovanför lådan på ramen. Efter att ha låtit limmet torka kunde jag enkelt och bekvämt ta bort eller byta ut Pi på plats med bara de två skruvarna. Jag har.stl för armbågen länkad nedan.

Anslut nu bara motordrivrutinen till PI med IN1, IN2, IN3, IN4 anslutning till GPIO 14, 15, 18, 23. Slutligen, anslut 5v- och jordstiftet på styrkortet till 5v -utgången och jordstiftet på Pi.

Här är en länk till Pi's Pinout för lite referens:

Steg 11: Montera kameran

Att montera kameran var något mindre robust än Pi men metoden fick jobbet gjort. Efter att ha designat och skrivit ut en tunn balk med 2 hål i varje ände fästade jag strålen till Rasberry Pi genom sitt monteringshål. Fäst sedan bara kameran i den motsatta änden av strålen med en annan skruv. Ta-da! Det ser fin fluga ut.

Steg 12: Skapa och montera lådans rörelse-mekanism

Detta steg blev enkelt tack vare de alltid välvilliga gåvorna från tillverkargemenskapen. Efter en snabb sökning på Thingiverse kunde jag hitta en linjär aktuator skapad av TucksProjects (finns här: https://www.thingiverse.com/thing:2987762). Det var bara att slå det på ett SD -kort och låta skrivaren göra jobbet.

Jag hamnade i Fusion 360 och redigerade spåret eftersom axeln på min motor var för stor för den som tillhandahålls av TucksProjects. Jag har.stl för det nedan. Efter att utskriften gjorts behöver vi bara montera den genom att placera spåret på motoraxeln, sedan genom att fästa motorn och höljessidorna med 2 skruvar (se till att du sätter in racket emellan innan du stänger det). Jag slutade med att behöva klippa en tum av stället så att det skulle passa mellan lådan och ramen.

Nu återstår bara att fästa mekanismen på ramen och lådan. "Men hur ska vi göra det?" du frågar … japp, säg det med mig: Superlim. Som visas på bilderna ovan, placera bara mekanismen mot botten av ramen och skjut den upp mot träbiten som lådan glider på. Det är viktigt här att du försöker få racket/mekanismen så parallell med ramen som möjligt så att när mekanismen rör sig skjuter den lådan rakt och inte i vinkel. När limmet har torkat, lägg lite mer lim på kanten av stället och flytta lådan på plats och låt det torka. När vi är klara har vi en robust mekanism för att skjuta in vår hemliga låda och ut.

Steg 13: Lägga till kartong bakom spegeln

För att få den här tvåvägsfilmen att se mer spegelaktig ut fann jag att den tjänar vårt syfte väl att placera kartong bakom glaset. Kartongen som används är en som följde med ramen men alla bitar som klipps för att passa kommer att fungera. Detta säkerställer inte heller något ljus från kamerans LED, motorstyrenheten eller Pi visar på andra sidan av spegeln. Med allt på plats använder du en penna för att markera var kameran sitter på kartongen. Använd sedan en rakhyvel för att skära en rektangel så att kameran kan kika igenom när den är på plats.

Steg 14: Sätta på det sista stycket

Det sista du ska göra är att sätta på den främre delen av lådan som var avsatt tidigare. Flytta motorn så att lådan sticker ut. Limma sedan fast den främre delen så att lådstycket är centrerat (det ska hänga lite på alla sidor. Sedan kan du bara hänga det på en vägg.

Steg 15: Avsluta

Där har du det! Det finns flera förbättringar som kan göras, till exempel att lägga till den tryckknappen, köpa en bättre tvåvägsfilm och fixa den buggen i koden, men sammantaget får det jobbet gjort: det ser ut som en spegel, det känner igen det förutbestämda användarens ansikte och den öppnar den söta lilla lådan. Som alltid skulle jag gärna höra dina tankar, frågor och memoarer i kommentarerna nedan.

Totalbetyg: 10/10

Kommentarer: #WouldNotTryAgain … om jag inte kunde följa detta instruerbara;)

Stora priset i den hemliga utdelningsutmaningen