<input type="hidden" name="templateid" value="6d5df9e5-f557-4eab-b01f-9d5d52527323"/>

For further information on the phyBOARD-Pollux, go to  https://www.phytec.de/produkte/system-on-modules/phycore-imx-8m-plus/#downloads/. There you will find the following documentation:

• QS Guide: A short guide on how to set up and boot a phyCORE board along with brief information on building a BSP, the device tree, and accessing peripherals.
• Hardware Manual:  A detailed description of the System on Module and accompanying carrier board. 
• Yocto Guide:  A comprehensive guide for the Yocto version the phyCORE uses. This guide contains an overview of Yocto; introducing, installing, and customizing the PHYTEC BSP; how to work with programs like Poky and Bitbake; and much more.
• BSP Manual:  A manual specific to the BSP version of the phyCORE. Information such as how to build the BSP, booting, updating software, device tree, and accessing peripherals can be found here.
• Development Environment Guide:  This guide shows how to work with the Virtual Machine (VM) Host PHYTEC has developed and prepared to run various Development Environments. There are detailed step-by-step instructions for Eclipse and Qt Creator, which are included in the VM. There are instructions for running demo projects for these programs on a phyCORE product as well. Information on how to build a Linux host PC yourself is also a part of this guide.
• Pinout Table:  phyCORE SOMs have an accompanying pin table (in Excel format). This table will show the complete default signal path, from processor to carrier board. The default device tree muxing option will also be included. This gives a developer all the information needed in one location to make muxing changes and design options when developing a specialized carrier board or adapting a PHYTEC phyCORE SOM to an application. 

On top of these standard manuals and guides, PHYTEC will also provide Product Change Notifications, Application Notes, and Technical Notes. These will be done on a case-by-case basis. 

For more information or details regarding the phyCORE-i.MX 8M Plus / phyBOARD-Pollux, please go to our phyCORE i.MX 8M Plus Product page or contact the PHYTEC Sales department.

This kit is provided with a special SD-Card image, which might differ from our general purpose evaluation kit SD-Card Image based on the standard PHYTEC BSP. So if you want to use any of the other manuals provided for this kit, you might need to download the standard phytec image in order to ensure the functions described in those other manuals are available.

host$ cd ~/yocto
host$ wget https://download.phytec.de/Software/Linux/Yocto/Tools/phyLinux
host$ chmod +x phyLinux
host$ MACHINE=phyboard-pollux-imx8mp-1 DISTRO=yogurt-vendor-xwayland ./phyLinux init -p topic -r PD-BSP-Yocto-CelebrityFaceMatch-i.MX8MP-v0.2

1  from keras_vggface_TF.vggfaceTF import VGGFace
2  from keras_vggface_TF import utils
3  pretrained_model = VGGFace(model='resnet50', include_top=False, input_shape=(224, 224, 3), pooling='avg') # pooling: None, avg or max

If you are looking to use this commercially, please read this article to learn how to tune a license-free dataset to perform better.

#Removing the files

lowembeddings=[]
removelist=[]
for idx in EMBEDDINGS_temp.index:
    if EMBEDDINGS_temp.MeanEmb[idx] > 100:
        print(EMBEDDINGS_temp.MeanEmb[idx])
        print('removing: ' + str(path_crops / EMBEDDINGS_temp.Name[idx] / EMBEDDINGS_temp.File[idx]))
        os.remove(str(path_crops / EMBEDDINGS_temp.Name[idx] / EMBEDDINGS_temp.File[idx]))# Remove the file
        EMBEDDINGS_modified=EMBEDDINGS_temp.drop(EMBEDDINGS_temp.index[idx]) # Remove that line from the Embeddings
        lowembeddings.append(str(Path(path_crops / celeb / f))) #Add info to file

filename_csv= path_crops / 'modified.csv'
filename_json= path_crops / 'modified.json'
EMBEDDINGS_modified.to_csv(Path(Path.cwd() / filename_csv), index=False)
EMBEDDINGS_modified.to_json(Path(Path.cwd() / filename_json))
print(time.time()-time1)

1  import json 
2  f = open((embeddingpath + embeddingsfile),'r') 
3  ImportedData =json.load(f)
4  dataE=[np.array(ImportedData['Embedding'][str(i)]) for i in range(len(ImportedData['Name']))]
5  dataN=[np.array(ImportedData['Name'][str(i)]) for i in range(len(ImportedData['Name']))]
6  dataF=[np.array(ImportedData['File'][str(i)]) for i in range(len(ImportedData['Name']))]

1  try: 
2      interpreter = tf.lite.Interpreter(model_path) 
3  except ValueError as e:
4      print("Error: Modelfile could not be found. Check if you are in the correct workdirectory. Errormessage: " + str(e))
5      #Depending on the version of TF running, check where lite is set :
6      if tf.__version__.startswith ('1.'):
7          print('lite in dir(tf.contrib)' + str('lite' in dir(tf.contrib)))
8      elif tf.__version__.startswith ('2.'):
9          print('lite in dir(tf)? ' + str('lite' in dir(tf)))
10
11  interpreter.allocate_tensors()
12
13  # Get input and output tensors.
14  input_details = interpreter.get_input_details()
15  output_details = interpreter.get_output_details() 

1  #face_cascade = cv2.CascadeClassifier(cascaderpath + 'haarcascade_frontalface_alt.xml')
2  face_cascade = cv2.CascadeClassifier(cascaderpath + 'lbpcascade_frontalface_improved.xml')

1  def preprocess_input(x, data_format): #Choose version same as in " 2-Create embeddings database.py or jupyter"
2      x_temp = np.copy(x)
3      if data_format is None:
4          data_format = tf.keras.backend.image_data_format()
5      assert data_format in {'channels_last', 'channels_first'}
6
7      if data_format == 'channels_first':
8         x_temp = x_temp[:, ::-1, ...]
9         x_temp[:, 0, :, :] -= 91.4953
10        x_temp[:, 1, :, :] -= 103.8827
11        x_temp[:, 2, :, :] -= 131.0912
12     else:
13        x_temp = x_temp[..., ::-1]
14        x_temp[..., 0] -= 91.4953
15        x_temp[..., 1] -= 103.8827
16        x_temp[..., 2] -= 131.0912
17
18     return x_temp

1  def splitDataFrameIntoSmaller(df, chunkSize):
2      listOfDf = list()
3      numberChunks = len(df) // chunkSize + 1
4      for i in range(numberChunks):
5          listOfDf.append(df[i*chunkSize:(i+1)*chunkSize])
6      return listOfDf
7
8  def faceembedding(YourFace,CelebDaten):
9      Dist=[]
10     for i in range(len(CelebDaten.File)):
11         Celebs=np.array(CelebDaten.Embedding[i]) 
12         Dist.append(np.linalg.norm(YourFace-Celebs))
13     return Dist
14
15  def faceembeddingNP(YourFace,CelebDaten):
16      Dist=[]
17      for i in range(len(CelebDaten)):
18          Celebs=np.array(CelebDaten[i]) 
19          Dist.append(np.linalg.norm(YourFace-Celebs))
20      return Dist
21
22  # Split data for threadding
23  #-----------------------------------------------------------------------------
24  celeb_embeddings=splitDataFrameIntoSmaller(dataE, int(np.ceil(len(dataE)/4))) 

1    videodev = 'video0'
2    buildinfo = cv2.getBuildInformation() 
3    if buildinfo.find("GStreamer") < 0: 
4        print('no GStreamer support in OpenCV') 
5        exit(0) 
6
7    path = os.path.join('/sys/bus/i2c/devices', '2-0010', 'driver')
8    if not os.path.exists(path):
9        return None
10
11   cmd = 'media-ctl -V "31:0[fmt:SGRBG8_1X8/1280x800 (4,4)/1280x800]"' 
12   ret = subprocess.call(cmd, shell=True)
13   cmd = 'media-ctl -V "22:0[fmt:SGRBG8_1X8/1280x800]"' 
14   ret = subprocess.call(cmd, shell=True)
15   cmd = 'v4l2-ctl -d0 -v width=1280,height=800,pixelformat=GRBG' #set size and format
16   ret = subprocess.call(cmd, shell=True)
17   cmd = 'v4l2-ctl -d0 -c vertical_flip=1' #If the image is flipped.
18   ret = subprocess.call(cmd, shell=True)
19   cmd = 'v4l2-ctl -c horizontal_blanking=2500'
20   ret = subprocess.call(cmd, shell=True)
21   cmd = 'v4l2-ctl -c digital_gain_red=1400' #If needed color corrections
22   ret = subprocess.call(cmd, shell=True)
23   cmd = 'v4l2-ctl -c digital_gain_blue=1700' #If needed color corrections
24   ret = subprocess.call(cmd, shell=True)
25
26   pipeline = 'v4l2src device=/dev/{video} ! appsink'.format(video=videodev)
27

1  cap = cv2.VideoCapture(pipeline, cv2.CAP_GSTREAMER)
2
3  while(True):
4  # CAPTURE FRAME BY FRAME 
5      ret, frame = cap.read() 
6      frame=cv2.cvtColor(frame, cv2.COLOR_BAYER_GB2RGB)
7      cv2.namedWindow('frame', cv2.WND_PROP_FULLSCREEN)
8      cv2.setWindowProperty('frame', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
9      cv2.imshow('frame', frame)

1  #DECTECT FACE IN VIDEO CONTINUOUSLY 
2      faces_detected = face_cascade.detectMultiScale(frame, scaleFactor=1.2, minNeighbors=5)#, Size(50,50))
3      for (x,y,w,h) in faces_detected:
4           rechteck=cv2.rectangle(frame, (x-p, y-p+2), (x+w+p, y+h+p+2), (0, 255, 0), 2) 
5           #rechteck=cv2.rectangle(frame, (x-p, y-p+2), (x+int(np.ceil(height))+p, y+int(np.ceil(height))+p+2), (0, 0, 100), 2) 
6           cv2.imshow('frame', rechteck) 

1   # DETECT KEY INPUT - ESC OR FIND MOST CENTERED FACE 
2       key = cv2.waitKey(1)
3       if key == 27: #Esc key
4            cap.release()
5            cv2.destroyAllWindows()
6            break
7       if key ==32: 
8          mittleres_Gesicht_X=()
9          mitte=()
10         if len(faces_detected) !=0: # only if the cascader detected a face, otherwise error
11            start1 = time()
12   #FIND MOST MIDDLE FACE 
13            for (x,y,w,h) in faces_detected:
14                mitte=np.append(mitte,(x+w/2)) 
15            mittleres_Gesicht_X = (np.abs(mitte - framemitte)).argmin()
16            print('detect middel face ' ,time()-start1)
17   # FRAME THE DETECTED FACE
18            start2=time()
19            #print(faces_detected[mittleres_Gesicht_X])
20            (x, y, w, h) = faces_detected[mittleres_Gesicht_X]
21            img=frame[y-p+2:y+h+p-2, x-p+2:x+w+p-2] #use only the detected face; crop it +2 to remove frame # CHECK IF IMAGE EMPTY (OUT OF IMAGE = EMPTY) 
22
23            if len(img) != 0: # Check if face is out of the frame, then img=[], throwing error
24                print('detect face ',time()-start2)
25
26   # CROP IMAGE 
27                start3=time()
28                if img.shape > (width,height): #downsampling
29                    img_small=cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA) #resize the image to desired dimensions e.g., 256x256 
30                elif img.shape < (width,height): #upsampling
31                    img_small=cv2.resize(img, (width, height), interpolation=cv2.INTER_CUBIC) #resize the image to desired dimensions e.g., 256x256 
32                cv2.imshow('frame',img_small)
33                cv2.waitKey(1) #hit any key
34                end3=time()
35                print('face crop', end3-start3)

1   # IMAGE PREPROCESSING
2                   start4=time()
3                   if inputtype=='int':
4                       samples = np.expand_dims(img_small, axis=0)
5                       samples = preprocess_input(samples, data_format=None, version=3).astype('int8')#data_format= None, 'channels_last', 'channels_first' . If None, it is determined automatically from the backend
6                   else:
7                       pixels = img_small.astype('float32')
8                       samples = np.expand_dims( pixels, axis=0)
9                       samples = preprocess_input(samples, data_format=None, version=2)#data_format= None, 'channels_last', 'channels_first' . If None, it is determined automatically from the backend
10                  #now using the tflight model
11                  print('preprocess data for model' , time()-start4)
12   # CREATE FACE EMBEDDINGS 
13                  if Loadtype=='armNN':
14                      prep=time()
15                      input_tensors = ann.make_input_tensors([input_binding_info], [samples])
16                      # Get output binding information for an output layer by using the layer name.
17                      output_binding_info = parser.GetNetworkOutputBindingInfo(0, 'model/output')
18                      output_tensors = ann.make_output_tensors([output_binding_info])
19                      runtime.EnqueueWorkload(0, input_tensors, output_tensors)
20                      print('ANN preperation ',time()-prep)
21                      start42=time()
22                      EMBEDDINGS=ann.workload_tensors_to_ndarray(output_tensors)
23                  elif Loadtype=='TL':
24                      prep=time()
25                      input_shape = input_details[0]['shape']
26                      input_data = samples
27                      interpreter.set_tensor(input_details[0]['index'], input_data)
28                      interpreter.invoke()
29                      print('ANN preperation ',time()-prep)
30                      start42=time()
31                      EMBEDDINGS = interpreter.get_tensor(output_details[0]['index'])
32                  print('create face embeddings' , time()-start42)

1   # READ CELEB EMBEDDINGS AND COMPARE 
2                   start_EU=time()
3                   EuDist=[]
4                   with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
5                       ergebniss_1=executor.submit(faceembeddingNP,EMBEDDINGS,np.array(celeb_embeddings[0]))
6                       ergebniss_2=executor.submit(faceembeddingNP,EMBEDDINGS,np.array(celeb_embeddings[1]))
7                       ergebniss_3=executor.submit(faceembeddingNP,EMBEDDINGS,np.array(celeb_embeddings[2]))
8                       ergebniss_4=executor.submit(faceembeddingNP,EMBEDDINGS,np.array(celeb_embeddings[3]))
9
10                  if ergebniss_1.done() & ergebniss_2.done() & ergebniss_3.done() & ergebniss_4.done():
11                      EuDist.extend(ergebniss_1.result())
12                      EuDist.extend(ergebniss_2.result())
13                      EuDist.extend(ergebniss_3.result())
14                      EuDist.extend(ergebniss_4.result())
15                  print('Create_EuDist', time()-start_EU)
16
17                  start_Min=time()
18                  idx = np.argpartition(EuDist, 5) 
19                  folder_idx= dataN[idx[0]]
20                  image_idx = dataF[idx[0]] 
21                  print('find minimum for facematch', time()-start_Min)

1  #Load the h5 model 
2  pretrained_model = tf.keras.models.load_model('my_model.h5')
3  #Then use the converter as before
4  converter = tf.lite.TFLiteConverter.from_keras_model(pretrained_model)

1  # Or load the pb file from the modelfolder 
2  # TensorFlow version >2.x
3
4  converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) # the folder contains the pb file and a assets and variables folder

1  import keras 
2  ...
3  pretrained_model.save('my_model.h5')