Saravanan666/pypi-org huggingface dataset:
Package: face-recons
Finding set of faces when combined results in face of person AThis repository contains the code for the python project on “Finding set of faces when combined results in face of person A".
The default mode of the application is interactive mode which is user friendly. The other mode is Command Line Interface.Default Mode (Interactive Mode):We start the application by opening the terminal in this folder and typing the command :  python main.pyThe following 5 options are shown in the terminal. Then we would enter the number of the command of our choice between 1-5.
If we enter 1, the directory for training dataset is asked. Then the model starts to train & following output is generated.
If we enter 2, then the full file path to test directory is asked. Then the collage of input/test images are printed as output on terminal.
If we enter 3, then the mean face and first five eigen faces get printed on the output window one by one.
The mean face is displayed on the output window.
Then, all the five eigen faces will be displayed on the output window one by one.
If we enter 4, then the trained model is read from pca_parameters.yml.Then the eigen vectors held in a structure of eigenVectors where eigen_face[i][j] = j-th eigen face of i-th image are displayed on the terminal as shown below.Then we enter the name of folder with image in format: directory/image_name.jpg. The image will be read and vectorized. After that the final results get displayed in new window. The final output window with original image on left and re-constructed image on right as described in the video below.It has a slider for increasing or decreasing the number of eigen faces used for reconstruction. By trying all combinations, we can dynamically see the best reconstructed image.The reconstructed image dynamically changes with respect to the number of eigen faces chosen on slider.The percentage of Eigen Faces used for reconstructing output image is dynamically printed on the terminal as we move the slider.Finally to exit the terminal we must enter 5. If we enter any other value than 1 to 5 then "invalid mode" output will be displayed.Mode 1 (Command Line Interface)If we wish to use the Command Line Interface, we can do so by typing the following command :python main.py --mode 1 --input directory/image.jpg --dataset directoryWe can enter mode = 1 for CLI mode, the directory/../image.jpg for the Test Image and the directory for the Training Dataset.
For example, if we entered test/300000.jpg for Test Image and sample2 for Training Dataset.
The model is trained from the pca_parameters.yml and the Test Image is reconstructed.
The percentage of Eigen Faces used to reconstruct the output image is dynamically printed on terminal as we slide the slider.Same Output Window of Reconstructed Image is displayed in CLI mode as seen in Interactive Mode.
Package: facereg
faceregfaceregis a module for face recognition with OpenCV and Deep Learning.For now it can be used for just images. It is easy to use with a handy feature
which downloads images from Google for you with given keywords to create dataset/s.Uses two different technicsCNNandHoGfor recognition based ondlib’s
face recognition system with usingface_recognition.facereghas totally three different layers and only recognizer has connection on encoder.PrerequisitesCMakeAll dependencies are listed onrequirements.txtand will be installed when you install withpip.InstallationInstall module usingpip:$ pip install faceregDownload the latestfacereglibrary from:https://github.com/verifid/faceregand install module usingpip:$ pip install -e .Extract the source distribution and run:$ python setup.py build
$ python setup.py installUsagegoogle_images:importosfromfaceregimportgoogle_imagesoutput_directory=os.getcwd()+'/datasets'# directory path where you want to save photosimage_paths=google_images.download('michael jordan',limit=3)face_encoder:importosfromfaceregimportface_encoderdatasets_path=os.getcwd()+'/datasets'encodings_path=os.path.dirname(os.path.realpath(__file__))+'/encodings.pickle'# these are default values for this methodface_encoder.encode_faces(datasets=datasets_path,encodings=encodings_path,detection_method='cnn')recognize_faces:fromfaceregimportrecognize_facesimage_path='DIRECTORY PATH OF YOUR_IMAGE'names=recognize_faces.recognize(image_path)# returns found names from your datasetsCLI UsageDownload images# -d: keyword, -l: limit
$ python -m facereg -d 'michael jordan'
$ python -m facereg -d 'michael jordan' -l 5Recognition# -i: Directory path for image
$ python -m facereg -i tests/resources/michael_jordan.jpegSample Result
Package: face_scrambler
## OverviewPython package that creates scrambled versions of images of human faces.## Installation### 1. Install AnacondaYou need to install the scientific Python Distribution Anaconda.
Go to the [official download page](https://www.continuum.io/downloads) and klick on the link to download the Graphical 64-bit Installer for your system. It is important that you choose thePython 2.7version, not 3.6, as this package is not compatible with Python 3.x. Start the downloaded Installer and follow the steps. The installation might take a while.### 2. Get OpenCVThe package depends on the popular Computer Vision library OpenCV.
Open a Terminal (Command Prompt in MS Windows) and type the following:$ conda install -c menpo opencvWhen asked, typeyand Enter to confirm the installation.### 3. Install face_scramblerIn the terminal, enter the following command:$ pip install face_scrambler## UsageOpen the Interface by entering thescramblerinto a terminal and confirming with enter.[more information tbd]## Implementation DetailsTBD
Package: facesdk
A python package for face analysis.DocumentationSeehttps://github.com/foamliu/facesdkfor a complete reference manual and introductory tutorials.InstallationThe latest stable release is available on PyPI, and you can install it by saying` pip install facesdk `If all went well, you should be able to execute the demo scripts underexamples/ExamplesRun face detection demo:` python examples/detect.py `![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_detection.jpg)Run face recognition demo:` python examples/recognize.py `![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_recog_0.jpg)![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_recog_1.jpg)![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_recog_2.jpg)![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_recog_3.jpg)![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_recog_4.jpg)![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_recog_5.jpg)![image](https://github.com/foamliu/facesdk/raw/master/examples/output/face_recog_6.jpg)
Package: faceservice
faceservicePython Boilerplate contains all the boilerplate you need to create a Python package.Free software: MIT licenseDocumentation:https://faceservice.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-05-03)First release on PyPI.
Package: faceshine
Face Shine ServerThis project is an AI Photo Enhancer running over PytorchFeaturesFace enhancementSuper ResolutionErase ScratchesColorize PhotoEnhance lightsClear backgroundInstallfoo@bar:~$pipinstallfaceshinefoo@bar:~$faceshineSuper FaceFrontend GUIThe frontend GUI for Face Shine still is under development, nevertheless source code is available for testing purposes.For developers:All PyTorch models are available atHugging Face
Package: face-symmetrizer
face-symmetrizerEasy symmetrizer for an image contained face(s)Installpipinstallface-symmetrizerHowHere is an example image of two peopleCommand$ fsym -h
usage: fsym [-h] [-s] [-S] [-q] [-o dir] file [file ...]

Easy symmetrizer for an image contained face(s)

positional arguments:
  file                  input image files

optional arguments:
  -h, --help            show this help message and exit
  -s, --show            show images (default: False)
  -S, --save            save images (default: False)
  -q, --quiet           make log quiet (default: False)
  -o dir, --outdir dir  directory when saving images (default: .)Detect with window and save symmetrized images tooutimg$ fsym img/two_people.jpg -o outimg -s --save
[+]image: img/two_people.jpg
[+]2 face(s) was detected.
[+]face: 0 # open window when using `-s`
[+]save: outimg/two_people.face-0.left_cropped.jpg
[+]save: outimg/two_people.face-0.left_cropped_inner.jpg
[+]save: outimg/two_people.face-0.left_cropped_outer.jpg
[+]save: outimg/two_people.face-0.right_cropped.jpg
[+]save: outimg/two_people.face-0.right_cropped_inner.jpg
[+]save: outimg/two_people.face-0.right_cropped_outer.jpg
[+]face: 1 # open window when using `-s`
[+]save: outimg/two_people.face-1.left_cropped.jpg
[+]save: outimg/two_people.face-1.left_cropped_inner.jpg
[+]save: outimg/two_people.face-1.left_cropped_outer.jpg
[+]save: outimg/two_people.face-1.right_cropped.jpg
[+]save: outimg/two_people.face-1.right_cropped_inner.jpg
[+]save: outimg/two_people.face-1.right_cropped_outer.jpgLibraryFirst, load an imagefromface_symmetrizerimportFaceSym# load from local file pathf=FaceSym("img/two_people.jpg")# or, load from URL# f = FaceSym("https://raw.githubusercontent.com/ageitgey/"#             "face_recognition/master/examples/two_people.jpg")# ATTRS: ['image_location',#         'f_img', 'f_img_PIL', 'image_size',#         'face_locations', 'face_landmarks',#         'mid_face_locations', 'face_count']Get & show a full imagef.get_full_image(show=True)#=> <PIL.Image.Image>Get & show an image of a rectangle drawn around a face.f.get_face_box_drawed_image(show=True)#=> <PIL.Image.Image>Get & show cropped face(s)f.get_cropped_face_images(show=True)#=> [<PIL.Image.Image>, ...]Get & show symmetrized images (face: 0)f.get_symmetrized_images(show=True,idx=0)#=> (left_cropped, left_cropped_inner, left_cropped_outer,#    right_cropped, right_cropped_inner, right_cropped_outer)Get & show symmetrized images (face: 1)f.get_symmetrized_images(show=True,idx=1)LICENSEMIT
Package: faceted
The purpose of this module is to make it easy to produce single-or-multi-panel
figures in matplotlib with strict dimensional constraints. For example, perhaps
you would like to make a figure that fits exactly within a column of a
manuscript without any scaling, and you would like the panels to be as large as
possible, but retain a fixed aspect ratio (height divided by width). Maybe some
(or all) of your panels require an accompanying colorbar. With out of the box
matplotlib tools this is actually somewhat tricky.Internally, this module uses the flexible [matplotlibAxesGridtoolkit](https://matplotlib.org/2.0.2/mpl_toolkits/axes_grid/users/overview.html#axes-grid1),
with some additional logic to enable making these kinds of
dimensionally-constrained
panel plots with precise padding and colorbar size(s).Another project with a similar motivation is [panel-plots](https://github.com/ajdawson/panel-plots); however it does not have support
for adding colorbars to a dimensionally-constrained figure.  One part of the
implementation there that inspired part of what is done here is the ability
to add user-settable padding to the edges of the figure (to add space for
axes ticks, ticklabels, and labels).  This eliminates the need for usingbbox_inches=’tight’when saving the figure, and enables you
to make sure that your figures areexactlythe dimensions you need for your
use.Important linksHTML documentation:https://faceted.readthedocs.io/en/latest/Issue tracker:https://github.com/spencerkclark/faceted/issuesSource code:https://github.com/spencerkclark/faceted
Package: facetranscript
FaceDatabse-IdentifierA simple python package to identify the user on bases of there face and store there features in databasePrerequisite :Must have GCC for dlib to workSample Code :fromfacetranscriptimportCaptureFaceInDataBaseif__name__=="__main__":face=CaptureFaceInDataBase()# Capture photo from front camera for user -> 'TestUser'face.take_photo(username="TestUser")# Fetch all stored users and there images in databaseface_list=face.get_all_users()# face_list is list [a,b,c...] where a,b,c.. are list of users with there images(Bytes)print(face_list)# To terminate all connections (camera/database)face.close_all_connections()Delete user from database :To delete a single userfromfacetranscriptimportCaptureFaceInDataBaseface=CaptureFaceInDataBase()# delete_user_data returns bool value if it is True user is deletedis_user_deleted=face.delete_user_data("TestUser")To drop the complete tablefromfacetranscriptimportCaptureFaceInDataBaseface=CaptureFaceInDataBase()# is_table_dropped returns bool value if it is True table is deletedis_table_dropped=face.drop_table()
Package: facetswrapper
facets-wrapperA wrapper to two visualizations inFacets, namely Facets Overview and Facets Dive.Facets Overview wrapperThe general idea follows one of the providedoriginal examples.The wrapper takes only one dataframe as input, but allows to use optionally a list of columns to perform a groupby. In such a case, the groups of the groupby correspond to the multiple datasets of the original example.The CSS of the wrapping HTML page is used to tweak the HTML code returned by facets, in order to accommodate gracefully more than 2 groups of data. A sprinkle of JavaScript is also used to enhance some functionalities.Facets Dive wrapperNot yet implemented, planned for end of may 2019.
Package: face-utils
face utilsthis is an opensource wrapper library for the most common face detection models.It also provides multiple face utilities such as face cropping.Supported detection modelsface_recognition (hog and cnn)retina face modelhaar cascade face detectionmore to be added in the next releasesInstallationOS X & Linux using PIP :pipinstallface-utilsFeaturesFace DetectionBy creating an object of the face detection model you want you can use it to detect the faces in images.I have also implemented outputs forms such as
1 : (x,y,w,h) and  2 : (top,right,bottom,left )Face croppingability to crop the  face from the image given the detector resultYou can also zoom in and out from the face.Exampleimportcv2fromface_utils.detectionimportDetectorfromface_utils.croppingimportcroppingimgPath="files/Obama.jpg"img=cv2.imread(imgPath)img=np.array(img)model=Detector("hog")bbox=model.detect(img,2)#using (x,y,w,h) return modeface=cropping.crop(img,bbox,1,80,80)input :output :TODO::add images loading function (opencv and PIL)add multiple faces detection for retina face modeladd x1,y1,x2,y2 for detection moduleadd encoding featureadd shape drawing around facesadd test scriptsRelease History0.1.0three detection models with one simple cropping moduleLicenseMITCOPYRIGHT© Digified 2021
Package: facex
Facex : Facial Expression Classifier API powered by TensorflowBefore use, you need to install :Tensorflow >= 2.0.0Python >= 3.6Usage example :importcv2importfacexclasifier=facexim=cv2.imread("try.jpeg")gray=cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)res=clasifier.predict(gray)Result example:({'anger':0.998833,'disgust':0.00052476715,'fear':2.7101655e-06,'happy':1.9320699e-15,'neutral':2.370802e-06,'sadness':0.00063713803,'surprised':1.0851344e-09},'anger')The result will a tuple of probability of each category and the highest probability category.
Package: facexlib
FaceXLibEnglish|简体中文facexlibaims at providing ready-to-useface-relatedfunctions based on current SOTA open-source methods.Only PyTorch reference codes are available. For training or fine-tuning, please refer to their original repositories listed below.Note that we just provide a collection of these algorithms. You need to refer to their original LICENCEs for your intended use.If facexlib is helpful in your projects, please help to :star: this repo. Thanks:blush:Other recommended projects:   :arrow_forward:Real-ESRGAN:arrow_forward:GFPGAN:arrow_forward:BasicSR:sparkles: FunctionsFunctionSourcesOriginal LICENSEDetectionPytorch_RetinafaceMITAlignmentAdaptiveWingLossApache 2.0RecognitionInsightFace_PytorchMITParsingface-parsing.PyTorchMITMattingMODNetCC 4.0Headposedeep-head-poseApache 2.0TrackingSORTGPL 3.0AssessmenthyperIQA-UtilsFace Restoration Helper-:eyes: Demo and Tutorials:wrench: Dependencies and InstallationPython >= 3.7 (Recommend to useAnacondaorMiniconda)PyTorch >= 1.7Option: NVIDIA GPU +CUDAInstallationpipinstallfacexlibPre-trained modelsIt willautomaticallydownload pre-trained models at the first inference.If your network is not stable, you can download in advance (may with other download tools), and put them in the folder:PACKAGE_ROOT_PATH/facexlib/weights.:scroll: License and AcknowledgementThis project is released under the MIT license.:e-mail: ContactIf you have any question, open an issue or emailxintao.wang@outlook.com.
Package: facho
fachoLibreria para facturacion electronica colombia.facho/facho.py: abstracion para manipulacion del XMLfacho/fe/form.py: abstraciones para creacion de facturas.facho/fe/form_xml.py(DIANInvoiceXML): decora abstraciones con campos requeridos por la DIAN.facho/fe/fe.py(DianXMLExtensionSigner): extension para firmar xmlfacho/fe/client/dian.py(DianClient): cliente para consultas sincronicas a API de DIANINSTALACIONusando pip:pip install git+https://git.disroot.org/Etrivial/fachoCLItambien se provee linea de comandosfachopara generacion, firmado y envio de documentos::facho –helpCONTRIBUIRverCONTRIBUTING.rstUSOverUSAGE.rstDIAN HABILITACIONguia oficial actualizada al 2020-04-20:https://www.dian.gov.co/fizcalizacioncontrol/herramienconsulta/FacturaElectronica/Facturaci%C3%B3n_Gratuita_DIAN/Documents/Guia_usuario_08052019.pdf#search=numeracionHistory0.2.1 version usada en produccion.
Package: facial-emotion-recognition
Project DescriptionFacial Emotion Recognition using PyTorch.

It creates a bounding box around the face of the person present in the picture and put a text
at the top of the bounding box representing the recognised emotion.Installpip install emotion_recognitionRequirementspytorch >= 1.2.0torchvision >= 0.3.0Usage:from facial_emotion_recognition import EmotionRecognition

import cv2 as cv

er = EmotionRecognition(device='gpu', gpu_id=0)

cam = cv.VideoCapture(0)

success, frame = cam.read()

frame = er.recognise_emotion(frame, return_type='BGR')

cv.imshow("frame", frame)

while True:
    key = cv.waitKey(10)
    if key & 0xff == 27:
        breakArgumentser = EmotionRecognition(device='gpu', gpu_id=0)

device = 'gpu' or cpu'

gpu_id will be effective only when more than two GPUs are detected or it will through error.

frame = er.recognise_emotion(frame, return_type='BGR')

return_type='BGR' or 'RGB'References"Challenges in Representation Learning: A report on three machine learning
contests." I Goodfellow, D Erhan, PL Carrier, A Courville, M Mirza, B
Hamner, W Cukierski, Y Tang, DH Lee, Y Zhou, C Ramaiah, F Feng, R Li,
X Wang, D Athanasakis, J Shawe-Taylor, M Milakov, J Park, R Ionescu,
M Popescu, C Grozea, J Bergstra, J Xie, L Romaszko, B Xu, Z Chuang, and
Y. Bengio. arXiv 2013.
Package: facialis-palsy-file-models
Facialis Palsy File ModelsIntroductionThere exist some Grading Systems for Facial Palsy. These Gradings are mostly saved in own developed File Formats.
This Repository trys to define a standardised file format for the most common grading systems.File FormatThe File Format is based on theJSONFormat.
This library implements a pydantic base model for the JSON Format definition and parsing.ModelsSunnybrookThe Sunnybrook Grading System is defined in theSunnybrook Facial Grading System: Reliability and Criteria for Nasolabial FoldPaper.The Model is defined in thefacialis_palsy.models.sunnybrookModule.House BrackmannThe Sunnybrook Grading System is defined in:House, J.W., Brackmann, D.E. Facial nerve grading system. Otolaryngol. Head Neck Surg, [93] 146–147. 1985.The Model is defined in thefacialis_palsy.models.house_brackmannModule.Grade I - NormalNormal facial function in all areasGrade II - Slight DysfunctionGross: slight weakness noticeable on close inspection; may have very slight synkinesis
At rest: normal symmetry and tone
Motion: forehead - moderate to good function; eye - complete closure with minimum effort; mouth - slight asymmetry.Grade III - Moderate DysfunctionGross: obvious but not disfiguring difference between two sides; noticeable but not severe synkinesis, contracture, and/or hemi-facial spasm.
At rest: normal symmetry and tone
Motion: forehead - slight to moderate movement; eye - complete closure with effort; mouth - slightly weak with maximum effort.Grade IV - Moderate Severe DysfunctionGross: obvious weakness and/or disfiguring asymmetry
At rest: normal symmetry and tone
Motion: forehead - none; eye - incomplete closure; mouth - asymmetric with maximum effort.Grade V - Severe DysfunctionGross: only barely perceptible motion
At rest: asymmetry
Motion: forehead - none; eye - incomplete closure; mouth - slight movementGrade VI - Total ParalysisNo movementDescription of House Brackmann Grading ScaleYanagiharaThe Yanagihara Grading System is defined in theYanagihara Grading System for Facial PalsyPaper.The Model is defined in thefacialis_palsy.models.yanagiharaModule.eFACEThe eFACE Grading System is defined in theeFACE: A New Clinical Tool to Evaluate Facial FunctionPaper.The Model is defined in thefacialis_palsy.models.efaceModule.Additional MetadataWe define some additional Metadata for the File Format.metadata_version_number: "0.0.0"
application_version: str = "APPLICATION_VERSION"
application_org: str = "ORGANIZATION_DOMAIN"The metadata_version_number gets updated via pythonchange_version_number.pyscript.
This script updates the version number in all files accordingly to thesetup.py.The application_version and application_org are specific to the application which uses this library and writes the files.
Package: faciescanner
faciescannerfaciescanner is a Python package as Techlog plug-in, which automate facies classifaction from borehole image.installationTo install faciescanner, you need to navigate to Python3 folder of Techlog using command prompt.
The usual Techlog Python3 folder address likes this: "C:\Program Files\Schlumberger\Techlog Version\Python3".
Code in: python.exe -m pip install faciescanner and hit execute, that is it.usageThe model has been trained with EfficientNetB4 pre-trained model using local FMI image and geolgical interpretation. It might be used in same geological area with caution, while local expertise is very important and advised though.As for pratical manipulation, it requires to open a new python eiditor in Techlog and paste below coding inside, add image array and depth in paramters area. The parameters name should be consistent with python coding.Code to use in python script area:from faciescanner.data_input import DataInputdi = DataInput(FMI_STAT_FULL,TDEP)
df_output, X = di.image2chunk()
df_pred = di.predict(df_output, X)
di.create_new_zone(df_pred)Hit Launch in PythonScript menu of Techlog, result will be avlaible under well in Techlog.contributingIf you'd like to contribute to faciescanner, please contact me.licenseMy Package is licensed under the MIT License. See LICENSE for more information.