rollback default code

handler.py

@@ -14,10 +14,6 @@ from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel
 
 from huggingface_hub import hf_hub_download
 
-import sys
-root_local = './'
-sys.path.insert(0, root_local)
-
 from insightface.app import FaceAnalysis
 
 from style_template import styles

insightface/__init__.py

@@ -1,21 +0,0 @@
-# coding: utf-8
-# pylint: disable=wrong-import-position
-"""InsightFace: A Face Analysis Toolkit."""
-from __future__ import absolute_import
-
-try:
-    #import mxnet as mx
-    import onnxruntime
-except ImportError:
-    raise ImportError(
-        "Unable to import dependency onnxruntime. "
-    )
-
-__version__ = '0.7.3'
-
-from . import model_zoo
-from . import utils
-from . import app
-from . import data
-from . import thirdparty
-

insightface/app/__init__.py

@@ -1,2 +0,0 @@
-from .face_analysis import *
-from .mask_renderer import *

insightface/app/common.py

@@ -1,49 +0,0 @@
-import numpy as np
-from numpy.linalg import norm as l2norm
-#from easydict import EasyDict
-
-class Face(dict):
-
-    def __init__(self, d=None, **kwargs):
-        if d is None:
-            d = {}
-        if kwargs:
-            d.update(**kwargs)
-        for k, v in d.items():
-            setattr(self, k, v)
-        # Class attributes
-        #for k in self.__class__.__dict__.keys():
-        #    if not (k.startswith('__') and k.endswith('__')) and not k in ('update', 'pop'):
-        #        setattr(self, k, getattr(self, k))
-
-    def __setattr__(self, name, value):
-        if isinstance(value, (list, tuple)):
-            value = [self.__class__(x)
-                    if isinstance(x, dict) else x for x in value]
-        elif isinstance(value, dict) and not isinstance(value, self.__class__):
-            value = self.__class__(value)
-        super(Face, self).__setattr__(name, value)
-        super(Face, self).__setitem__(name, value)
-
-    __setitem__ = __setattr__
-
-    def __getattr__(self, name):
-        return None
-
-    @property
-    def embedding_norm(self):
-        if self.embedding is None:
-            return None
-        return l2norm(self.embedding)
-
-    @property 
-    def normed_embedding(self):
-        if self.embedding is None:
-            return None
-        return self.embedding / self.embedding_norm
-
-    @property 
-    def sex(self):
-        if self.gender is None:
-            return None
-        return 'M' if self.gender==1 else 'F'

insightface/app/face_analysis.py

@@ -1,109 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Organization  : insightface.ai
-# @Author        : Jia Guo
-# @Time          : 2021-05-04
-# @Function      : 
-
-
-from __future__ import division
-
-import glob
-import os.path as osp
-
-import numpy as np
-import onnxruntime
-from numpy.linalg import norm
-
-from ..model_zoo import model_zoo
-from ..utils import DEFAULT_MP_NAME, ensure_available
-from .common import Face
-
-__all__ = ['FaceAnalysis']
-
-class FaceAnalysis:
-    def __init__(self, name=DEFAULT_MP_NAME, root='~/.insightface', allowed_modules=None, **kwargs):
-        onnxruntime.set_default_logger_severity(3)
-        self.models = {}
-        self.model_dir = ensure_available('models', name, root=root)
-        onnx_files = glob.glob(osp.join(self.model_dir, '*.onnx'))
-        onnx_files = sorted(onnx_files)
-        for onnx_file in onnx_files:
-            model = model_zoo.get_model(onnx_file, **kwargs)
-            if model is None:
-                print('model not recognized:', onnx_file)
-            elif allowed_modules is not None and model.taskname not in allowed_modules:
-                print('model ignore:', onnx_file, model.taskname)
-                del model
-            elif model.taskname not in self.models and (allowed_modules is None or model.taskname in allowed_modules):
-                print('find model:', onnx_file, model.taskname, model.input_shape, model.input_mean, model.input_std)
-                self.models[model.taskname] = model
-            else:
-                print('duplicated model task type, ignore:', onnx_file, model.taskname)
-                del model
-        assert 'detection' in self.models
-        self.det_model = self.models['detection']
-
-
-    def prepare(self, ctx_id, det_thresh=0.5, det_size=(640, 640)):
-        self.det_thresh = det_thresh
-        assert det_size is not None
-        print('set det-size:', det_size)
-        self.det_size = det_size
-        for taskname, model in self.models.items():
-            if taskname=='detection':
-                model.prepare(ctx_id, input_size=det_size, det_thresh=det_thresh)
-            else:
-                model.prepare(ctx_id)
-
-    def get(self, img, max_num=0):
-        bboxes, kpss = self.det_model.detect(img,
-                                             max_num=max_num,
-                                             metric='default')
-        if bboxes.shape[0] == 0:
-            return []
-        ret = []
-        for i in range(bboxes.shape[0]):
-            bbox = bboxes[i, 0:4]
-            det_score = bboxes[i, 4]
-            kps = None
-            if kpss is not None:
-                kps = kpss[i]
-            face = Face(bbox=bbox, kps=kps, det_score=det_score)
-            for taskname, model in self.models.items():
-                if taskname=='detection':
-                    continue
-                model.get(img, face)
-            ret.append(face)
-        return ret
-
-    def draw_on(self, img, faces):
-        import cv2
-        dimg = img.copy()
-        for i in range(len(faces)):
-            face = faces[i]
-            box = face.bbox.astype(int)
-            color = (0, 0, 255)
-            cv2.rectangle(dimg, (box[0], box[1]), (box[2], box[3]), color, 2)
-            if face.kps is not None:
-                kps = face.kps.astype(int)
-                #print(landmark.shape)
-                for l in range(kps.shape[0]):
-                    color = (0, 0, 255)
-                    if l == 0 or l == 3:
-                        color = (0, 255, 0)
-                    cv2.circle(dimg, (kps[l][0], kps[l][1]), 1, color,
-                               2)
-            if face.gender is not None and face.age is not None:
-                cv2.putText(dimg,'%s,%d'%(face.sex,face.age), (box[0]-1, box[1]-4),cv2.FONT_HERSHEY_COMPLEX,0.7,(0,255,0),1)
-
-            #for key, value in face.items():
-            #    if key.startswith('landmark_3d'):
-            #        print(key, value.shape)
-            #        print(value[0:10,:])
-            #        lmk = np.round(value).astype(int)
-            #        for l in range(lmk.shape[0]):
-            #            color = (255, 0, 0)
-            #            cv2.circle(dimg, (lmk[l][0], lmk[l][1]), 1, color,
-            #                       2)
-        return dimg
-

insightface/app/mask_renderer.py

@@ -1,232 +0,0 @@
-import os, sys, datetime
-import numpy as np
-import os.path as osp
-import albumentations as A
-from albumentations.core.transforms_interface import ImageOnlyTransform
-from .face_analysis import FaceAnalysis
-from ..utils import get_model_dir
-from ..thirdparty import face3d
-from ..data import get_image as ins_get_image
-from ..utils import DEFAULT_MP_NAME
-import cv2
-
-class MaskRenderer:
-    def __init__(self, name=DEFAULT_MP_NAME, root='~/.insightface', insfa=None):
-        #if insfa is None, enter render_only mode
-        self.mp_name = name
-        self.root = root
-        self.insfa = insfa
-        model_dir = get_model_dir(name, root)
-        bfm_file = osp.join(model_dir, 'BFM.mat')
-        assert osp.exists(bfm_file), 'should contains BFM.mat in your model directory'
-        self.bfm = face3d.morphable_model.MorphabelModel(bfm_file)
-        self.index_ind = self.bfm.kpt_ind
-        bfm_uv_file = osp.join(model_dir, 'BFM_UV.mat')
-        assert osp.exists(bfm_uv_file), 'should contains BFM_UV.mat in your model directory'
-        uv_coords = face3d.morphable_model.load.load_uv_coords(bfm_uv_file)
-        self.uv_size = (224,224)
-        self.mask_stxr =  0.1
-        self.mask_styr = 0.33
-        self.mask_etxr = 0.9
-        self.mask_etyr =  0.7
-        self.tex_h , self.tex_w, self.tex_c = self.uv_size[1] , self.uv_size[0],3
-        texcoord = np.zeros_like(uv_coords)
-        texcoord[:, 0] = uv_coords[:, 0] * (self.tex_h - 1)
-        texcoord[:, 1] = uv_coords[:, 1] * (self.tex_w - 1)
-        texcoord[:, 1] = self.tex_w - texcoord[:, 1] - 1
-        self.texcoord = np.hstack((texcoord, np.zeros((texcoord.shape[0], 1))))
-        self.X_ind = self.bfm.kpt_ind
-        self.mask_image_names = ['mask_white', 'mask_blue', 'mask_black', 'mask_green']
-        self.mask_aug_probs = [0.4, 0.4, 0.1, 0.1]
-        #self.mask_images = []
-        #self.mask_images_rgb = []
-        #for image_name in mask_image_names:
-        #    mask_image = ins_get_image(image_name)
-        #    self.mask_images.append(mask_image)
-        #    mask_image_rgb = mask_image[:,:,::-1]
-        #    self.mask_images_rgb.append(mask_image_rgb)
-
-
-    def prepare(self, ctx_id=0, det_thresh=0.5, det_size=(128, 128)):
-        self.pre_ctx_id = ctx_id
-        self.pre_det_thresh = det_thresh
-        self.pre_det_size = det_size
-
-    def transform(self, shape3D, R):
-        s = 1.0
-        shape3D[:2, :] = shape3D[:2, :]
-        shape3D = s * np.dot(R, shape3D)
-        return shape3D
-
-    def preprocess(self, vertices, w, h):
-        R1 = face3d.mesh.transform.angle2matrix([0, 180, 180])
-        t = np.array([-w // 2, -h // 2, 0])
-        vertices = vertices.T
-        vertices += t
-        vertices = self.transform(vertices.T, R1).T
-        return vertices
-
-    def project_to_2d(self,vertices,s,angles,t):
-        transformed_vertices = self.bfm.transform(vertices, s, angles, t)
-        projected_vertices = transformed_vertices.copy() # using stantard camera & orth projection
-        return projected_vertices[self.bfm.kpt_ind, :2]
-
-    def params_to_vertices(self,params  , H , W):
-        fitted_sp, fitted_ep, fitted_s, fitted_angles, fitted_t  = params
-        fitted_vertices = self.bfm.generate_vertices(fitted_sp, fitted_ep)
-        transformed_vertices = self.bfm.transform(fitted_vertices, fitted_s, fitted_angles,
-                                                  fitted_t)
-        transformed_vertices = self.preprocess(transformed_vertices.T, W, H)
-        image_vertices = face3d.mesh.transform.to_image(transformed_vertices, H, W)
-        return image_vertices
-
-    def draw_lmk(self, face_image):
-        faces = self.insfa.get(face_image, max_num=1)
-        if len(faces)==0:
-            return face_image
-        return self.insfa.draw_on(face_image, faces)
-
-    def build_params(self, face_image):
-        #landmark = self.if3d68_handler.get(face_image)
-        #if landmark is None:
-        #    return None #face not found
-        if self.insfa is None:
-            self.insfa = FaceAnalysis(name=self.mp_name, root=self.root, allowed_modules=['detection', 'landmark_3d_68'])
-            self.insfa.prepare(ctx_id=self.pre_ctx_id,  det_thresh=self.pre_det_thresh, det_size=self.pre_det_size)
-
-        faces = self.insfa.get(face_image, max_num=1)
-        if len(faces)==0:
-            return None
-        landmark = faces[0].landmark_3d_68[:,:2]
-        fitted_sp, fitted_ep, fitted_s, fitted_angles, fitted_t = self.bfm.fit(landmark, self.X_ind, max_iter = 3)
-        return [fitted_sp, fitted_ep, fitted_s, fitted_angles, fitted_t]
-
-    def generate_mask_uv(self,mask, positions):
-        uv_size = (self.uv_size[1], self.uv_size[0], 3)
-        h, w, c = uv_size
-        uv = np.zeros(shape=(self.uv_size[1],self.uv_size[0], 3), dtype=np.uint8)
-        stxr, styr  = positions[0], positions[1]
-        etxr, etyr = positions[2], positions[3]
-        stx, sty = int(w * stxr), int(h * styr)
-        etx, ety = int(w * etxr), int(h * etyr)
-        height = ety - sty
-        width = etx - stx
-        mask = cv2.resize(mask, (width, height))
-        uv[sty:ety, stx:etx] = mask
-        return uv
-
-    def render_mask(self,face_image, mask_image, params, input_is_rgb=False, auto_blend = True, positions=[0.1, 0.33, 0.9, 0.7]):
-        if isinstance(mask_image, str):
-            to_rgb = True if input_is_rgb else False
-            mask_image = ins_get_image(mask_image, to_rgb=to_rgb)
-        uv_mask_image = self.generate_mask_uv(mask_image, positions)
-        h,w,c = face_image.shape
-        image_vertices = self.params_to_vertices(params ,h,w)
-        output = (1-face3d.mesh.render.render_texture(image_vertices, self.bfm.full_triangles , uv_mask_image, self.texcoord, self.bfm.full_triangles, h , w ))*255
-        output = output.astype(np.uint8)
-        if auto_blend:
-            mask_bd = (output==255).astype(np.uint8)
-            final = face_image*mask_bd + (1-mask_bd)*output
-            return final
-        return output
-
-    #def mask_augmentation(self, face_image, label, input_is_rgb=False, p=0.1):
-    #    if np.random.random()<p:
-    #        assert isinstance(label, (list, np.ndarray)), 'make sure the rec dataset includes mask params'
-    #        assert len(label)==237 or len(lable)==235, 'make sure the rec dataset includes mask params'
-    #        if len(label)==237:
-    #            if label[1]<0.0: #invalid label for mask aug
-    #                return face_image
-    #            label = label[2:]
-    #        params = self.decode_params(label)
-    #        mask_image_name = np.random.choice(self.mask_image_names, p=self.mask_aug_probs)
-    #        pos = np.random.uniform(0.33, 0.5)
-    #        face_image = self.render_mask(face_image, mask_image_name, params, input_is_rgb=input_is_rgb, positions=[0.1, pos, 0.9, 0.7])
-    #    return face_image
-
-    @staticmethod
-    def encode_params(params):
-        p0 = list(params[0])
-        p1 = list(params[1])
-        p2 = [float(params[2])]
-        p3 = list(params[3])
-        p4 = list(params[4])
-        return p0+p1+p2+p3+p4
-
-    @staticmethod
-    def decode_params(params):
-        p0 = params[0:199]
-        p0 = np.array(p0, dtype=np.float32).reshape( (-1, 1))
-        p1 = params[199:228]
-        p1 = np.array(p1, dtype=np.float32).reshape( (-1, 1))
-        p2 = params[228]
-        p3 = tuple(params[229:232])
-        p4 = params[232:235]
-        p4 = np.array(p4, dtype=np.float32).reshape( (-1, 1))
-        return p0, p1, p2, p3, p4
-    
-class MaskAugmentation(ImageOnlyTransform):
-
-    def __init__(
-            self,
-            mask_names=['mask_white', 'mask_blue', 'mask_black', 'mask_green'],
-            mask_probs=[0.4,0.4,0.1,0.1],
-            h_low = 0.33,
-            h_high = 0.35,
-            always_apply=False,
-            p=1.0,
-            ):
-        super(MaskAugmentation, self).__init__(always_apply, p)
-        self.renderer = MaskRenderer()
-        assert len(mask_names)>0
-        assert len(mask_names)==len(mask_probs)
-        self.mask_names = mask_names
-        self.mask_probs = mask_probs
-        self.h_low = h_low
-        self.h_high = h_high
-        #self.hlabel = None
-
-
-    def apply(self, image, hlabel, mask_name, h_pos, **params):
-        #print(params.keys())
-        #hlabel = params.get('hlabel')
-        assert len(hlabel)==237 or len(hlabel)==235, 'make sure the rec dataset includes mask params'
-        if len(hlabel)==237:
-            if hlabel[1]<0.0:
-                return image
-            hlabel = hlabel[2:]
-        #print(len(hlabel))
-        mask_params = self.renderer.decode_params(hlabel)
-        image = self.renderer.render_mask(image, mask_name, mask_params, input_is_rgb=True, positions=[0.1, h_pos, 0.9, 0.7])
-        return image
-
-    @property
-    def targets_as_params(self):
-        return ["image", "hlabel"]
-
-    def get_params_dependent_on_targets(self, params):
-        hlabel = params['hlabel']
-        mask_name = np.random.choice(self.mask_names, p=self.mask_probs)
-        h_pos = np.random.uniform(self.h_low, self.h_high)
-        return {'hlabel': hlabel, 'mask_name': mask_name, 'h_pos': h_pos}
-
-    def get_transform_init_args_names(self):
-        #return ("hlabel", 'mask_names', 'mask_probs', 'h_low', 'h_high')
-        return ('mask_names', 'mask_probs', 'h_low', 'h_high')
-
-
-if __name__ == "__main__":
-    tool = MaskRenderer('antelope')
-    tool.prepare(det_size=(128,128))
-    image = cv2.imread("Tom_Hanks_54745.png")
-    params = tool.build_params(image)
-    #out = tool.draw_lmk(image)
-    #cv2.imwrite('output_lmk.jpg', out)
-    #mask_image  = cv2.imread("masks/mask1.jpg")
-    #mask_image  = cv2.imread("masks/black-mask.png")
-    #mask_image  = cv2.imread("masks/mask2.jpg")
-    mask_out = tool.render_mask(image, 'mask_blue', params)# use single thread to test the time cost
-
-    cv2.imwrite('output_mask.jpg', mask_out)
-
-

insightface/commands/__init__.py

@@ -1,13 +0,0 @@
-from abc import ABC, abstractmethod
-from argparse import ArgumentParser
-
-
-class BaseInsightFaceCLICommand(ABC):
-    @staticmethod
-    @abstractmethod
-    def register_subcommand(parser: ArgumentParser):
-        raise NotImplementedError()
-
-    @abstractmethod
-    def run(self):
-        raise NotImplementedError()

insightface/commands/insightface_cli.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python
-
-from argparse import ArgumentParser
-
-from .model_download import ModelDownloadCommand
-from .rec_add_mask_param import RecAddMaskParamCommand
-
-def main():
-    parser = ArgumentParser("InsightFace CLI tool", usage="insightface-cli <command> [<args>]")
-    commands_parser = parser.add_subparsers(help="insightface-cli command-line helpers")
-
-    # Register commands
-    ModelDownloadCommand.register_subcommand(commands_parser)
-    RecAddMaskParamCommand.register_subcommand(commands_parser)
-
-    args = parser.parse_args()
-
-    if not hasattr(args, "func"):
-        parser.print_help()
-        exit(1)
-
-    # Run
-    service = args.func(args)
-    service.run()
-
-
-if __name__ == "__main__":
-    main()
-

insightface/commands/model_download.py

@@ -1,36 +0,0 @@
-from argparse import ArgumentParser
-
-from . import BaseInsightFaceCLICommand
-import os
-import os.path as osp
-import zipfile
-import glob
-from ..utils import download
-
-
-def model_download_command_factory(args):
-    return ModelDownloadCommand(args.model, args.root, args.force)
-
-
-class ModelDownloadCommand(BaseInsightFaceCLICommand):
-    #_url_format = '{repo_url}models/{file_name}.zip'
-    @staticmethod
-    def register_subcommand(parser: ArgumentParser):
-        download_parser = parser.add_parser("model.download")
-        download_parser.add_argument(
-            "--root", type=str, default='~/.insightface', help="Path to location to store the models"
-        )
-        download_parser.add_argument(
-            "--force", action="store_true", help="Force the model to be download even if already in root-dir"
-        )
-        download_parser.add_argument("model", type=str, help="Name of the model to download")
-        download_parser.set_defaults(func=model_download_command_factory)
-
-    def __init__(self, model: str, root: str, force: bool):
-        self._model = model
-        self._root = root
-        self._force = force
-
-    def run(self):
-        download('models', self._model, force=self._force, root=self._root)
-

insightface/commands/rec_add_mask_param.py

@@ -1,94 +0,0 @@
-
-import numbers
-import os
-from argparse import ArgumentParser, Namespace
-
-import mxnet as mx
-import numpy as np
-
-from ..app import MaskRenderer
-from ..data.rec_builder import RecBuilder
-from . import BaseInsightFaceCLICommand
-
-
-def rec_add_mask_param_command_factory(args: Namespace):
-
-    return RecAddMaskParamCommand(
-        args.input, args.output
-    )
-
-
-class RecAddMaskParamCommand(BaseInsightFaceCLICommand):
-    @staticmethod
-    def register_subcommand(parser: ArgumentParser):
-        _parser = parser.add_parser("rec.addmaskparam")
-        _parser.add_argument("input", type=str, help="input rec")
-        _parser.add_argument("output", type=str, help="output rec, with mask param")
-        _parser.set_defaults(func=rec_add_mask_param_command_factory)
-
-    def __init__(
-        self,
-        input: str,
-        output: str,
-    ):
-        self._input = input
-        self._output = output
-
-
-    def run(self):
-        tool = MaskRenderer()
-        tool.prepare(ctx_id=0, det_size=(128,128))
-        root_dir = self._input
-        path_imgrec = os.path.join(root_dir, 'train.rec')
-        path_imgidx = os.path.join(root_dir, 'train.idx')
-        imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')
-        save_path = self._output
-        wrec=RecBuilder(path=save_path)
-        s = imgrec.read_idx(0)
-        header, _ = mx.recordio.unpack(s)
-        if header.flag > 0:
-            if len(header.label)==2:
-                imgidx = np.array(range(1, int(header.label[0])))
-            else:
-                imgidx = np.array(list(self.imgrec.keys))
-        else:
-            imgidx = np.array(list(self.imgrec.keys))
-        stat = [0, 0]
-        print('total:', len(imgidx))
-        for iid, idx in enumerate(imgidx):
-            #if iid==500000:
-            #    break
-            if iid%1000==0:
-                print('processing:', iid)
-            s = imgrec.read_idx(idx)
-            header, img = mx.recordio.unpack(s)
-            label = header.label
-            if not isinstance(label, numbers.Number):
-                label = label[0]
-            sample = mx.image.imdecode(img).asnumpy()
-            bgr = sample[:,:,::-1]
-            params = tool.build_params(bgr)
-            #if iid<10:
-            #    mask_out = tool.render_mask(bgr, 'mask_blue', params)
-            #    cv2.imwrite('maskout_%d.jpg'%iid, mask_out)
-            stat[1] += 1
-            if params is None:
-                wlabel = [label] + [-1.0]*236
-                stat[0] += 1
-            else:
-                #print(0, params[0].shape, params[0].dtype)
-                #print(1, params[1].shape, params[1].dtype)
-                #print(2, params[2])
-                #print(3, len(params[3]), params[3][0].__class__)
-                #print(4, params[4].shape, params[4].dtype)
-                mask_label = tool.encode_params(params)
-                wlabel = [label, 0.0]+mask_label # 237 including idlabel, total mask params size is 235
-                if iid==0:
-                    print('param size:', len(mask_label), len(wlabel), label)
-            assert len(wlabel)==237
-            wrec.add_image(img, wlabel)
-            #print(len(params))
-
-        wrec.close()
-        print('finished on', self._output, ', failed:', stat[0])
-

insightface/data/__init__.py

@@ -1,2 +0,0 @@
-from .image import get_image
-from .pickle_object import get_object

insightface/data/image.py

@@ -1,28 +0,0 @@
-import cv2
-import os
-import os.path as osp
-from pathlib import Path
-
-class ImageCache:
-    data = {}
-
-def get_image(name, to_rgb=False, use_cache=True):
-    key = (name, to_rgb)
-    if key in ImageCache.data:
-        return ImageCache.data[key]
-    images_dir = osp.join(Path(__file__).parent.absolute(), 'images')
-    ext_names = ['.jpg', '.png', '.jpeg']
-    image_file = None
-    for ext_name in ext_names:
-        _image_file = osp.join(images_dir, "%s%s"%(name, ext_name))
-        if osp.exists(_image_file):
-            image_file = _image_file
-            break
-    assert image_file is not None, '%s not found'%name
-    img = cv2.imread(image_file)
-    if to_rgb:
-        img = img[:,:,::-1]
-    if use_cache:
-        ImageCache.data[key] = img
-    return img
-

insightface/data/objects/meanshape_68.pkl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:39ffecf84ba73f0d0d7e49380833ba88713c9fcdec51df4f7ac45a48b8f4cc51
-size 974

insightface/data/pickle_object.py

@@ -1,17 +0,0 @@
-import cv2
-import os
-import os.path as osp
-from pathlib import Path
-import pickle
-
-def get_object(name):
-    objects_dir = osp.join(Path(__file__).parent.absolute(), 'objects')
-    if not name.endswith('.pkl'):
-        name = name+".pkl"
-    filepath = osp.join(objects_dir, name)
-    if not osp.exists(filepath):
-        return None
-    with open(filepath, 'rb') as f:
-        obj = pickle.load(f)
-    return obj
-

insightface/data/rec_builder.py

@@ -1,71 +0,0 @@
-import pickle
-import numpy as np
-import os
-import os.path as osp
-import sys
-import mxnet as mx
-
-
-class RecBuilder():
-    def __init__(self, path, image_size=(112, 112)):
-        self.path = path
-        self.image_size = image_size
-        self.widx = 0
-        self.wlabel = 0
-        self.max_label = -1
-        assert not osp.exists(path), '%s exists' % path
-        os.makedirs(path)
-        self.writer = mx.recordio.MXIndexedRecordIO(os.path.join(path, 'train.idx'), 
-                                                    os.path.join(path, 'train.rec'),
-                                                    'w')
-        self.meta = []
-
-    def add(self, imgs):
-        #!!! img should be BGR!!!!
-        #assert label >= 0
-        #assert label > self.last_label
-        assert len(imgs) > 0
-        label = self.wlabel
-        for img in imgs:
-            idx = self.widx
-            image_meta = {'image_index': idx, 'image_classes': [label]}
-            header = mx.recordio.IRHeader(0, label, idx, 0)
-            if isinstance(img, np.ndarray):
-                s = mx.recordio.pack_img(header,img,quality=95,img_fmt='.jpg')
-            else:
-                s = mx.recordio.pack(header, img)
-            self.writer.write_idx(idx, s)
-            self.meta.append(image_meta)
-            self.widx += 1
-        self.max_label = label
-        self.wlabel += 1
-
-
-    def add_image(self, img, label):
-        #!!! img should be BGR!!!!
-        #assert label >= 0
-        #assert label > self.last_label
-        idx = self.widx
-        header = mx.recordio.IRHeader(0, label, idx, 0)
-        if isinstance(label, list):
-            idlabel = label[0]
-        else:
-            idlabel = label
-        image_meta = {'image_index': idx, 'image_classes': [idlabel]}
-        if isinstance(img, np.ndarray):
-            s = mx.recordio.pack_img(header,img,quality=95,img_fmt='.jpg')
-        else:
-            s = mx.recordio.pack(header, img)
-        self.writer.write_idx(idx, s)
-        self.meta.append(image_meta)
-        self.widx += 1
-        self.max_label = max(self.max_label, idlabel)
-
-    def close(self):
-        with open(osp.join(self.path, 'train.meta'), 'wb') as pfile:
-            pickle.dump(self.meta, pfile, protocol=pickle.HIGHEST_PROTOCOL)
-        print('stat:', self.widx, self.wlabel)
-        with open(os.path.join(self.path, 'property'), 'w') as f:
-            f.write("%d,%d,%d\n" % (self.max_label+1, self.image_size[0], self.image_size[1]))
-            f.write("%d\n" % (self.widx))
-

insightface/model_zoo/__init__.py

@@ -1,6 +0,0 @@
-from .model_zoo import get_model
-from .arcface_onnx import ArcFaceONNX
-from .retinaface import RetinaFace
-from .scrfd import SCRFD
-from .landmark import Landmark
-from .attribute import Attribute

insightface/model_zoo/arcface_onnx.py

@@ -1,92 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Organization  : insightface.ai
-# @Author        : Jia Guo
-# @Time          : 2021-05-04
-# @Function      : 
-
-from __future__ import division
-import numpy as np
-import cv2
-import onnx
-import onnxruntime
-from ..utils import face_align
-
-__all__ = [
-    'ArcFaceONNX',
-]
-
-
-class ArcFaceONNX:
-    def __init__(self, model_file=None, session=None):
-        assert model_file is not None
-        self.model_file = model_file
-        self.session = session
-        self.taskname = 'recognition'
-        find_sub = False
-        find_mul = False
-        model = onnx.load(self.model_file)
-        graph = model.graph
-        for nid, node in enumerate(graph.node[:8]):
-            #print(nid, node.name)
-            if node.name.startswith('Sub') or node.name.startswith('_minus'):
-                find_sub = True
-            if node.name.startswith('Mul') or node.name.startswith('_mul'):
-                find_mul = True
-        if find_sub and find_mul:
-            #mxnet arcface model
-            input_mean = 0.0
-            input_std = 1.0
-        else:
-            input_mean = 127.5
-            input_std = 127.5
-        self.input_mean = input_mean
-        self.input_std = input_std
-        #print('input mean and std:', self.input_mean, self.input_std)
-        if self.session is None:
-            self.session = onnxruntime.InferenceSession(self.model_file, None)
-        input_cfg = self.session.get_inputs()[0]
-        input_shape = input_cfg.shape
-        input_name = input_cfg.name
-        self.input_size = tuple(input_shape[2:4][::-1])
-        self.input_shape = input_shape
-        outputs = self.session.get_outputs()
-        output_names = []
-        for out in outputs:
-            output_names.append(out.name)
-        self.input_name = input_name
-        self.output_names = output_names
-        assert len(self.output_names)==1
-        self.output_shape = outputs[0].shape
-
-    def prepare(self, ctx_id, **kwargs):
-        if ctx_id<0:
-            self.session.set_providers(['CPUExecutionProvider'])
-
-    def get(self, img, face):
-        aimg = face_align.norm_crop(img, landmark=face.kps, image_size=self.input_size[0])
-        face.embedding = self.get_feat(aimg).flatten()
-        return face.embedding
-
-    def compute_sim(self, feat1, feat2):
-        from numpy.linalg import norm
-        feat1 = feat1.ravel()
-        feat2 = feat2.ravel()
-        sim = np.dot(feat1, feat2) / (norm(feat1) * norm(feat2))
-        return sim
-
-    def get_feat(self, imgs):
-        if not isinstance(imgs, list):
-            imgs = [imgs]
-        input_size = self.input_size
-        
-        blob = cv2.dnn.blobFromImages(imgs, 1.0 / self.input_std, input_size,
-                                      (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
-        net_out = self.session.run(self.output_names, {self.input_name: blob})[0]
-        return net_out
-
-    def forward(self, batch_data):
-        blob = (batch_data - self.input_mean) / self.input_std
-        net_out = self.session.run(self.output_names, {self.input_name: blob})[0]
-        return net_out
-
-

insightface/model_zoo/attribute.py

@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Organization  : insightface.ai
-# @Author        : Jia Guo
-# @Time          : 2021-06-19
-# @Function      : 
-
-from __future__ import division
-import numpy as np
-import cv2
-import onnx
-import onnxruntime
-from ..utils import face_align
-
-__all__ = [
-    'Attribute',
-]
-
-
-class Attribute:
-    def __init__(self, model_file=None, session=None):
-        assert model_file is not None
-        self.model_file = model_file
-        self.session = session
-        find_sub = False
-        find_mul = False
-        model = onnx.load(self.model_file)
-        graph = model.graph
-        for nid, node in enumerate(graph.node[:8]):
-            #print(nid, node.name)
-            if node.name.startswith('Sub') or node.name.startswith('_minus'):
-                find_sub = True
-            if node.name.startswith('Mul') or node.name.startswith('_mul'):
-                find_mul = True
-            if nid<3 and node.name=='bn_data':
-                find_sub = True
-                find_mul = True
-        if find_sub and find_mul:
-            #mxnet arcface model
-            input_mean = 0.0
-            input_std = 1.0
-        else:
-            input_mean = 127.5
-            input_std = 128.0
-        self.input_mean = input_mean
-        self.input_std = input_std
-        #print('input mean and std:', model_file, self.input_mean, self.input_std)
-        if self.session is None:
-            self.session = onnxruntime.InferenceSession(self.model_file, None)
-        input_cfg = self.session.get_inputs()[0]
-        input_shape = input_cfg.shape
-        input_name = input_cfg.name
-        self.input_size = tuple(input_shape[2:4][::-1])
-        self.input_shape = input_shape
-        outputs = self.session.get_outputs()
-        output_names = []
-        for out in outputs:
-            output_names.append(out.name)
-        self.input_name = input_name
-        self.output_names = output_names
-        assert len(self.output_names)==1
-        output_shape = outputs[0].shape
-        #print('init output_shape:', output_shape)
-        if output_shape[1]==3:
-            self.taskname = 'genderage'
-        else:
-            self.taskname = 'attribute_%d'%output_shape[1]
-
-    def prepare(self, ctx_id, **kwargs):
-        if ctx_id<0:
-            self.session.set_providers(['CPUExecutionProvider'])
-
-    def get(self, img, face):
-        bbox = face.bbox
-        w, h = (bbox[2] - bbox[0]), (bbox[3] - bbox[1])
-        center = (bbox[2] + bbox[0]) / 2, (bbox[3] + bbox[1]) / 2
-        rotate = 0
-        _scale = self.input_size[0]  / (max(w, h)*1.5)
-        #print('param:', img.shape, bbox, center, self.input_size, _scale, rotate)
-        aimg, M = face_align.transform(img, center, self.input_size[0], _scale, rotate)
-        input_size = tuple(aimg.shape[0:2][::-1])
-        #assert input_size==self.input_size
-        blob = cv2.dnn.blobFromImage(aimg, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
-        pred = self.session.run(self.output_names, {self.input_name : blob})[0][0]
-        if self.taskname=='genderage':
-            assert len(pred)==3
-            gender = np.argmax(pred[:2])
-            age = int(np.round(pred[2]*100))
-            face['gender'] = gender
-            face['age'] = age
-            return gender, age
-        else:
-            return pred
-
-

insightface/model_zoo/inswapper.py

@@ -1,105 +0,0 @@
-import time
-import numpy as np
-import onnxruntime
-import cv2
-import onnx
-from onnx import numpy_helper
-from ..utils import face_align
-
-
-
-
-class INSwapper():
-    def __init__(self, model_file=None, session=None):
-        self.model_file = model_file
-        self.session = session
-        model = onnx.load(self.model_file)
-        graph = model.graph
-        self.emap = numpy_helper.to_array(graph.initializer[-1])
-        self.input_mean = 0.0
-        self.input_std = 255.0
-        #print('input mean and std:', model_file, self.input_mean, self.input_std)
-        if self.session is None:
-            self.session = onnxruntime.InferenceSession(self.model_file, None)
-        inputs = self.session.get_inputs()
-        self.input_names = []
-        for inp in inputs:
-            self.input_names.append(inp.name)
-        outputs = self.session.get_outputs()
-        output_names = []
-        for out in outputs:
-            output_names.append(out.name)
-        self.output_names = output_names
-        assert len(self.output_names)==1
-        output_shape = outputs[0].shape
-        input_cfg = inputs[0]
-        input_shape = input_cfg.shape
-        self.input_shape = input_shape
-        print('inswapper-shape:', self.input_shape)
-        self.input_size = tuple(input_shape[2:4][::-1])
-
-    def forward(self, img, latent):
-        img = (img - self.input_mean) / self.input_std
-        pred = self.session.run(self.output_names, {self.input_names[0]: img, self.input_names[1]: latent})[0]
-        return pred
-
-    def get(self, img, target_face, source_face, paste_back=True):
-        aimg, M = face_align.norm_crop2(img, target_face.kps, self.input_size[0])
-        blob = cv2.dnn.blobFromImage(aimg, 1.0 / self.input_std, self.input_size,
-                                      (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
-        latent = source_face.normed_embedding.reshape((1,-1))
-        latent = np.dot(latent, self.emap)
-        latent /= np.linalg.norm(latent)
-        pred = self.session.run(self.output_names, {self.input_names[0]: blob, self.input_names[1]: latent})[0]
-        #print(latent.shape, latent.dtype, pred.shape)
-        img_fake = pred.transpose((0,2,3,1))[0]
-        bgr_fake = np.clip(255 * img_fake, 0, 255).astype(np.uint8)[:,:,::-1]
-        if not paste_back:
-            return bgr_fake, M
-        else:
-            target_img = img
-            fake_diff = bgr_fake.astype(np.float32) - aimg.astype(np.float32)
-            fake_diff = np.abs(fake_diff).mean(axis=2)
-            fake_diff[:2,:] = 0
-            fake_diff[-2:,:] = 0
-            fake_diff[:,:2] = 0
-            fake_diff[:,-2:] = 0
-            IM = cv2.invertAffineTransform(M)
-            img_white = np.full((aimg.shape[0],aimg.shape[1]), 255, dtype=np.float32)
-            bgr_fake = cv2.warpAffine(bgr_fake, IM, (target_img.shape[1], target_img.shape[0]), borderValue=0.0)
-            img_white = cv2.warpAffine(img_white, IM, (target_img.shape[1], target_img.shape[0]), borderValue=0.0)
-            fake_diff = cv2.warpAffine(fake_diff, IM, (target_img.shape[1], target_img.shape[0]), borderValue=0.0)
-            img_white[img_white>20] = 255
-            fthresh = 10
-            fake_diff[fake_diff<fthresh] = 0
-            fake_diff[fake_diff>=fthresh] = 255
-            img_mask = img_white
-            mask_h_inds, mask_w_inds = np.where(img_mask==255)
-            mask_h = np.max(mask_h_inds) - np.min(mask_h_inds)
-            mask_w = np.max(mask_w_inds) - np.min(mask_w_inds)
-            mask_size = int(np.sqrt(mask_h*mask_w))
-            k = max(mask_size//10, 10)
-            #k = max(mask_size//20, 6)
-            #k = 6
-            kernel = np.ones((k,k),np.uint8)
-            img_mask = cv2.erode(img_mask,kernel,iterations = 1)
-            kernel = np.ones((2,2),np.uint8)
-            fake_diff = cv2.dilate(fake_diff,kernel,iterations = 1)
-            k = max(mask_size//20, 5)
-            #k = 3
-            #k = 3
-            kernel_size = (k, k)
-            blur_size = tuple(2*i+1 for i in kernel_size)
-            img_mask = cv2.GaussianBlur(img_mask, blur_size, 0)
-            k = 5
-            kernel_size = (k, k)
-            blur_size = tuple(2*i+1 for i in kernel_size)
-            fake_diff = cv2.GaussianBlur(fake_diff, blur_size, 0)
-            img_mask /= 255
-            fake_diff /= 255
-            #img_mask = fake_diff
-            img_mask = np.reshape(img_mask, [img_mask.shape[0],img_mask.shape[1],1])
-            fake_merged = img_mask * bgr_fake + (1-img_mask) * target_img.astype(np.float32)
-            fake_merged = fake_merged.astype(np.uint8)
-            return fake_merged
-

insightface/model_zoo/landmark.py

@@ -1,114 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Organization  : insightface.ai
-# @Author        : Jia Guo
-# @Time          : 2021-05-04
-# @Function      : 
-
-from __future__ import division
-import numpy as np
-import cv2
-import onnx
-import onnxruntime
-from ..utils import face_align
-from ..utils import transform
-from ..data import get_object
-
-__all__ = [
-    'Landmark',
-]
-
-
-class Landmark:
-    def __init__(self, model_file=None, session=None):
-        assert model_file is not None
-        self.model_file = model_file
-        self.session = session
-        find_sub = False
-        find_mul = False
-        model = onnx.load(self.model_file)
-        graph = model.graph
-        for nid, node in enumerate(graph.node[:8]):
-            #print(nid, node.name)
-            if node.name.startswith('Sub') or node.name.startswith('_minus'):
-                find_sub = True
-            if node.name.startswith('Mul') or node.name.startswith('_mul'):
-                find_mul = True
-            if nid<3 and node.name=='bn_data':
-                find_sub = True
-                find_mul = True
-        if find_sub and find_mul:
-            #mxnet arcface model
-            input_mean = 0.0
-            input_std = 1.0
-        else:
-            input_mean = 127.5
-            input_std = 128.0
-        self.input_mean = input_mean
-        self.input_std = input_std
-        #print('input mean and std:', model_file, self.input_mean, self.input_std)
-        if self.session is None:
-            self.session = onnxruntime.InferenceSession(self.model_file, None)
-        input_cfg = self.session.get_inputs()[0]
-        input_shape = input_cfg.shape
-        input_name = input_cfg.name
-        self.input_size = tuple(input_shape[2:4][::-1])
-        self.input_shape = input_shape
-        outputs = self.session.get_outputs()
-        output_names = []
-        for out in outputs:
-            output_names.append(out.name)
-        self.input_name = input_name
-        self.output_names = output_names
-        assert len(self.output_names)==1
-        output_shape = outputs[0].shape
-        self.require_pose = False
-        #print('init output_shape:', output_shape)
-        if output_shape[1]==3309:
-            self.lmk_dim = 3
-            self.lmk_num = 68
-            self.mean_lmk = get_object('meanshape_68.pkl')
-            self.require_pose = True
-        else:
-            self.lmk_dim = 2
-            self.lmk_num = output_shape[1]//self.lmk_dim
-        self.taskname = 'landmark_%dd_%d'%(self.lmk_dim, self.lmk_num)
-
-    def prepare(self, ctx_id, **kwargs):
-        if ctx_id<0:
-            self.session.set_providers(['CPUExecutionProvider'])
-
-    def get(self, img, face):
-        bbox = face.bbox
-        w, h = (bbox[2] - bbox[0]), (bbox[3] - bbox[1])
-        center = (bbox[2] + bbox[0]) / 2, (bbox[3] + bbox[1]) / 2
-        rotate = 0
-        _scale = self.input_size[0]  / (max(w, h)*1.5)
-        #print('param:', img.shape, bbox, center, self.input_size, _scale, rotate)
-        aimg, M = face_align.transform(img, center, self.input_size[0], _scale, rotate)
-        input_size = tuple(aimg.shape[0:2][::-1])
-        #assert input_size==self.input_size
-        blob = cv2.dnn.blobFromImage(aimg, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
-        pred = self.session.run(self.output_names, {self.input_name : blob})[0][0]
-        if pred.shape[0] >= 3000:
-            pred = pred.reshape((-1, 3))
-        else:
-            pred = pred.reshape((-1, 2))
-        if self.lmk_num < pred.shape[0]:
-            pred = pred[self.lmk_num*-1:,:]
-        pred[:, 0:2] += 1
-        pred[:, 0:2] *= (self.input_size[0] // 2)
-        if pred.shape[1] == 3:
-            pred[:, 2] *= (self.input_size[0] // 2)
-
-        IM = cv2.invertAffineTransform(M)
-        pred = face_align.trans_points(pred, IM)
-        face[self.taskname] = pred
-        if self.require_pose:
-            P = transform.estimate_affine_matrix_3d23d(self.mean_lmk, pred)
-            s, R, t = transform.P2sRt(P)
-            rx, ry, rz = transform.matrix2angle(R)
-            pose = np.array( [rx, ry, rz], dtype=np.float32 )
-            face['pose'] = pose #pitch, yaw, roll
-        return pred
-
-

insightface/model_zoo/model_store.py

@@ -1,103 +0,0 @@
-"""
-This code file mainly comes from https://github.com/dmlc/gluon-cv/blob/master/gluoncv/model_zoo/model_store.py
-"""
-from __future__ import print_function
-
-__all__ = ['get_model_file']
-import os
-import zipfile
-import glob
-
-from ..utils import download, check_sha1
-
-_model_sha1 = {
-    name: checksum
-    for checksum, name in [
-        ('95be21b58e29e9c1237f229dae534bd854009ce0', 'arcface_r100_v1'),
-        ('', 'arcface_mfn_v1'),
-        ('39fd1e087a2a2ed70a154ac01fecaa86c315d01b', 'retinaface_r50_v1'),
-        ('2c9de8116d1f448fd1d4661f90308faae34c990a', 'retinaface_mnet025_v1'),
-        ('0db1d07921d005e6c9a5b38e059452fc5645e5a4', 'retinaface_mnet025_v2'),
-        ('7dd8111652b7aac2490c5dcddeb268e53ac643e6', 'genderage_v1'),
-    ]
-}
-
-base_repo_url = 'https://insightface.ai/files/'
-_url_format = '{repo_url}models/{file_name}.zip'
-
-
-def short_hash(name):
-    if name not in _model_sha1:
-        raise ValueError(
-            'Pretrained model for {name} is not available.'.format(name=name))
-    return _model_sha1[name][:8]
-
-
-def find_params_file(dir_path):
-    if not os.path.exists(dir_path):
-        return None
-    paths = glob.glob("%s/*.params" % dir_path)
-    if len(paths) == 0:
-        return None
-    paths = sorted(paths)
-    return paths[-1]
-
-
-def get_model_file(name, root=os.path.join('~', '.insightface', 'models')):
-    r"""Return location for the pretrained on local file system.
-
-    This function will download from online model zoo when model cannot be found or has mismatch.
-    The root directory will be created if it doesn't exist.
-
-    Parameters
-    ----------
-    name : str
-        Name of the model.
-    root : str, default '~/.mxnet/models'
-        Location for keeping the model parameters.
-
-    Returns
-    -------
-    file_path
-        Path to the requested pretrained model file.
-    """
-
-    file_name = name
-    root = os.path.expanduser(root)
-    dir_path = os.path.join(root, name)
-    file_path = find_params_file(dir_path)
-    #file_path = os.path.join(root, file_name + '.params')
-    sha1_hash = _model_sha1[name]
-    if file_path is not None:
-        if check_sha1(file_path, sha1_hash):
-            return file_path
-        else:
-            print(
-                'Mismatch in the content of model file detected. Downloading again.'
-            )
-    else:
-        print('Model file is not found. Downloading.')
-
-    if not os.path.exists(root):
-        os.makedirs(root)
-    if not os.path.exists(dir_path):
-        os.makedirs(dir_path)
-
-    zip_file_path = os.path.join(root, file_name + '.zip')
-    repo_url = base_repo_url
-    if repo_url[-1] != '/':
-        repo_url = repo_url + '/'
-    download(_url_format.format(repo_url=repo_url, file_name=file_name),
-             path=zip_file_path,
-             overwrite=True)
-    with zipfile.ZipFile(zip_file_path) as zf:
-        zf.extractall(dir_path)
-    os.remove(zip_file_path)
-    file_path = find_params_file(dir_path)
-
-    if check_sha1(file_path, sha1_hash):
-        return file_path
-    else:
-        raise ValueError(
-            'Downloaded file has different hash. Please try again.')
-

insightface/model_zoo/model_zoo.py

@@ -1,98 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Organization  : insightface.ai
-# @Author        : Jia Guo
-# @Time          : 2021-05-04
-# @Function      : 
-
-import os
-import os.path as osp
-import glob
-import onnxruntime
-from .arcface_onnx import *
-from .retinaface import *
-#from .scrfd import *
-from .landmark import *
-from .attribute import Attribute
-from .inswapper import INSwapper
-from ..utils import download_onnx
-
-__all__ = ['get_model']
-
-
-class PickableInferenceSession(onnxruntime.InferenceSession): 
-    # This is a wrapper to make the current InferenceSession class pickable.
-    def __init__(self, model_path, **kwargs):
-        super().__init__(model_path, **kwargs)
-        self.model_path = model_path
-
-    def __getstate__(self):
-        return {'model_path': self.model_path}
-
-    def __setstate__(self, values):
-        model_path = values['model_path']
-        self.__init__(model_path)
-
-class ModelRouter:
-    def __init__(self, onnx_file):
-        self.onnx_file = onnx_file
-
-    def get_model(self, **kwargs):
-        session = PickableInferenceSession(self.onnx_file, **kwargs)
-        print(f'Applied providers: {session._providers}, with options: {session._provider_options}')
-        inputs = session.get_inputs()
-        input_cfg = inputs[0]
-        input_shape = input_cfg.shape
-        outputs = session.get_outputs()
-
-        if len(outputs)>=5:
-            return RetinaFace(model_file=self.onnx_file, session=session)
-        elif input_shape[2]==192 and input_shape[3]==192:
-            return Landmark(model_file=self.onnx_file, session=session)
-        elif input_shape[2]==96 and input_shape[3]==96:
-            return Attribute(model_file=self.onnx_file, session=session)
-        elif len(inputs)==2 and input_shape[2]==128 and input_shape[3]==128:
-            return INSwapper(model_file=self.onnx_file, session=session)
-        elif input_shape[2]==input_shape[3] and input_shape[2]>=112 and input_shape[2]%16==0:
-            return ArcFaceONNX(model_file=self.onnx_file, session=session)
-        else:
-            #raise RuntimeError('error on model routing')
-            return None
-
-def find_onnx_file(dir_path):
-    if not os.path.exists(dir_path):
-        return None
-    paths = glob.glob("%s/*.onnx" % dir_path)
-    if len(paths) == 0:
-        return None
-    paths = sorted(paths)
-    return paths[-1]
-
-def get_default_providers():
-    return ['CUDAExecutionProvider', 'CPUExecutionProvider']
-
-def get_default_provider_options():
-    return None
-
-def get_model(name, **kwargs):
-    root = kwargs.get('root', '~/.insightface')
-    root = os.path.expanduser(root)
-    model_root = osp.join(root, 'models')
-    allow_download = kwargs.get('download', False)
-    download_zip = kwargs.get('download_zip', False)
-    if not name.endswith('.onnx'):
-        model_dir = os.path.join(model_root, name)
-        model_file = find_onnx_file(model_dir)
-        if model_file is None:
-            return None
-    else:
-        model_file = name
-    if not osp.exists(model_file) and allow_download:
-        model_file = download_onnx('models', model_file, root=root, download_zip=download_zip)
-    assert osp.exists(model_file), 'model_file %s should exist'%model_file
-    assert osp.isfile(model_file), 'model_file %s should be a file'%model_file
-    router = ModelRouter(model_file)
-    providers = kwargs.get('providers', get_default_providers())
-    provider_options = kwargs.get('provider_options', get_default_provider_options())
-    model = router.get_model(providers=providers, provider_options=provider_options)
-    return model
-

insightface/model_zoo/retinaface.py

@@ -1,301 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Organization  : insightface.ai
-# @Author        : Jia Guo
-# @Time          : 2021-09-18
-# @Function      : 
-
-from __future__ import division
-import datetime
-import numpy as np
-import onnx
-import onnxruntime
-import os
-import os.path as osp
-import cv2
-import sys
-
-def softmax(z):
-    assert len(z.shape) == 2
-    s = np.max(z, axis=1)
-    s = s[:, np.newaxis] # necessary step to do broadcasting
-    e_x = np.exp(z - s)
-    div = np.sum(e_x, axis=1)
-    div = div[:, np.newaxis] # dito
-    return e_x / div
-
-def distance2bbox(points, distance, max_shape=None):
-    """Decode distance prediction to bounding box.
-
-    Args:
-        points (Tensor): Shape (n, 2), [x, y].
-        distance (Tensor): Distance from the given point to 4
-            boundaries (left, top, right, bottom).
-        max_shape (tuple): Shape of the image.
-
-    Returns:
-        Tensor: Decoded bboxes.
-    """
-    x1 = points[:, 0] - distance[:, 0]
-    y1 = points[:, 1] - distance[:, 1]
-    x2 = points[:, 0] + distance[:, 2]
-    y2 = points[:, 1] + distance[:, 3]
-    if max_shape is not None:
-        x1 = x1.clamp(min=0, max=max_shape[1])
-        y1 = y1.clamp(min=0, max=max_shape[0])
-        x2 = x2.clamp(min=0, max=max_shape[1])
-        y2 = y2.clamp(min=0, max=max_shape[0])
-    return np.stack([x1, y1, x2, y2], axis=-1)
-
-def distance2kps(points, distance, max_shape=None):
-    """Decode distance prediction to bounding box.
-
-    Args:
-        points (Tensor): Shape (n, 2), [x, y].
-        distance (Tensor): Distance from the given point to 4
-            boundaries (left, top, right, bottom).
-        max_shape (tuple): Shape of the image.
-
-    Returns:
-        Tensor: Decoded bboxes.
-    """
-    preds = []
-    for i in range(0, distance.shape[1], 2):
-        px = points[:, i%2] + distance[:, i]
-        py = points[:, i%2+1] + distance[:, i+1]
-        if max_shape is not None:
-            px = px.clamp(min=0, max=max_shape[1])
-            py = py.clamp(min=0, max=max_shape[0])
-        preds.append(px)
-        preds.append(py)
-    return np.stack(preds, axis=-1)
-
-class RetinaFace:
-    def __init__(self, model_file=None, session=None):
-        import onnxruntime
-        self.model_file = model_file
-        self.session = session
-        self.taskname = 'detection'
-        if self.session is None:
-            assert self.model_file is not None
-            assert osp.exists(self.model_file)
-            self.session = onnxruntime.InferenceSession(self.model_file, None)
-        self.center_cache = {}
-        self.nms_thresh = 0.4
-        self.det_thresh = 0.5
-        self._init_vars()
-
-    def _init_vars(self):
-        input_cfg = self.session.get_inputs()[0]
-        input_shape = input_cfg.shape
-        #print(input_shape)
-        if isinstance(input_shape[2], str):
-            self.input_size = None
-        else:
-            self.input_size = tuple(input_shape[2:4][::-1])
-        #print('image_size:', self.image_size)
-        input_name = input_cfg.name
-        self.input_shape = input_shape
-        outputs = self.session.get_outputs()
-        output_names = []
-        for o in outputs:
-            output_names.append(o.name)
-        self.input_name = input_name
-        self.output_names = output_names
-        self.input_mean = 127.5
-        self.input_std = 128.0
-        #print(self.output_names)
-        #assert len(outputs)==10 or len(outputs)==15
-        self.use_kps = False
-        self._anchor_ratio = 1.0
-        self._num_anchors = 1
-        if len(outputs)==6:
-            self.fmc = 3
-            self._feat_stride_fpn = [8, 16, 32]
-            self._num_anchors = 2
-        elif len(outputs)==9:
-            self.fmc = 3
-            self._feat_stride_fpn = [8, 16, 32]
-            self._num_anchors = 2
-            self.use_kps = True
-        elif len(outputs)==10:
-            self.fmc = 5
-            self._feat_stride_fpn = [8, 16, 32, 64, 128]
-            self._num_anchors = 1
-        elif len(outputs)==15:
-            self.fmc = 5
-            self._feat_stride_fpn = [8, 16, 32, 64, 128]
-            self._num_anchors = 1
-            self.use_kps = True
-
-    def prepare(self, ctx_id, **kwargs):
-        if ctx_id<0:
-            self.session.set_providers(['CPUExecutionProvider'])
-        nms_thresh = kwargs.get('nms_thresh', None)
-        if nms_thresh is not None:
-            self.nms_thresh = nms_thresh
-        det_thresh = kwargs.get('det_thresh', None)
-        if det_thresh is not None:
-            self.det_thresh = det_thresh
-        input_size = kwargs.get('input_size', None)
-        if input_size is not None:
-            if self.input_size is not None:
-                print('warning: det_size is already set in detection model, ignore')
-            else:
-                self.input_size = input_size
-
-    def forward(self, img, threshold):
-        scores_list = []
-        bboxes_list = []
-        kpss_list = []
-        input_size = tuple(img.shape[0:2][::-1])
-        blob = cv2.dnn.blobFromImage(img, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
-        net_outs = self.session.run(self.output_names, {self.input_name : blob})
-
-        input_height = blob.shape[2]
-        input_width = blob.shape[3]
-        fmc = self.fmc
-        for idx, stride in enumerate(self._feat_stride_fpn):
-            scores = net_outs[idx]
-            bbox_preds = net_outs[idx+fmc]
-            bbox_preds = bbox_preds * stride
-            if self.use_kps:
-                kps_preds = net_outs[idx+fmc*2] * stride
-            height = input_height // stride
-            width = input_width // stride
-            K = height * width
-            key = (height, width, stride)
-            if key in self.center_cache:
-                anchor_centers = self.center_cache[key]
-            else:
-                #solution-1, c style:
-                #anchor_centers = np.zeros( (height, width, 2), dtype=np.float32 )
-                #for i in range(height):
-                #    anchor_centers[i, :, 1] = i
-                #for i in range(width):
-                #    anchor_centers[:, i, 0] = i
-
-                #solution-2:
-                #ax = np.arange(width, dtype=np.float32)
-                #ay = np.arange(height, dtype=np.float32)
-                #xv, yv = np.meshgrid(np.arange(width), np.arange(height))
-                #anchor_centers = np.stack([xv, yv], axis=-1).astype(np.float32)
-
-                #solution-3:
-                anchor_centers = np.stack(np.mgrid[:height, :width][::-1], axis=-1).astype(np.float32)
-                #print(anchor_centers.shape)
-
-                anchor_centers = (anchor_centers * stride).reshape( (-1, 2) )
-                if self._num_anchors>1:
-                    anchor_centers = np.stack([anchor_centers]*self._num_anchors, axis=1).reshape( (-1,2) )
-                if len(self.center_cache)<100:
-                    self.center_cache[key] = anchor_centers
-
-            pos_inds = np.where(scores>=threshold)[0]
-            bboxes = distance2bbox(anchor_centers, bbox_preds)
-            pos_scores = scores[pos_inds]
-            pos_bboxes = bboxes[pos_inds]
-            scores_list.append(pos_scores)
-            bboxes_list.append(pos_bboxes)
-            if self.use_kps:
-                kpss = distance2kps(anchor_centers, kps_preds)
-                #kpss = kps_preds
-                kpss = kpss.reshape( (kpss.shape[0], -1, 2) )
-                pos_kpss = kpss[pos_inds]
-                kpss_list.append(pos_kpss)
-        return scores_list, bboxes_list, kpss_list
-
-    def detect(self, img, input_size = None, max_num=0, metric='default'):
-        assert input_size is not None or self.input_size is not None
-        input_size = self.input_size if input_size is None else input_size
-            
-        im_ratio = float(img.shape[0]) / img.shape[1]
-        model_ratio = float(input_size[1]) / input_size[0]
-        if im_ratio>model_ratio:
-            new_height = input_size[1]
-            new_width = int(new_height / im_ratio)
-        else:
-            new_width = input_size[0]
-            new_height = int(new_width * im_ratio)
-        det_scale = float(new_height) / img.shape[0]
-        resized_img = cv2.resize(img, (new_width, new_height))
-        det_img = np.zeros( (input_size[1], input_size[0], 3), dtype=np.uint8 )
-        det_img[:new_height, :new_width, :] = resized_img
-
-        scores_list, bboxes_list, kpss_list = self.forward(det_img, self.det_thresh)
-
-        scores = np.vstack(scores_list)
-        scores_ravel = scores.ravel()
-        order = scores_ravel.argsort()[::-1]
-        bboxes = np.vstack(bboxes_list) / det_scale
-        if self.use_kps:
-            kpss = np.vstack(kpss_list) / det_scale
-        pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False)
-        pre_det = pre_det[order, :]
-        keep = self.nms(pre_det)
-        det = pre_det[keep, :]
-        if self.use_kps:
-            kpss = kpss[order,:,:]
-            kpss = kpss[keep,:,:]
-        else:
-            kpss = None
-        if max_num > 0 and det.shape[0] > max_num:
-            area = (det[:, 2] - det[:, 0]) * (det[:, 3] -
-                                                    det[:, 1])
-            img_center = img.shape[0] // 2, img.shape[1] // 2
-            offsets = np.vstack([
-                (det[:, 0] + det[:, 2]) / 2 - img_center[1],
-                (det[:, 1] + det[:, 3]) / 2 - img_center[0]
-            ])
-            offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
-            if metric=='max':
-                values = area
-            else:
-                values = area - offset_dist_squared * 2.0  # some extra weight on the centering
-            bindex = np.argsort(
-                values)[::-1]  # some extra weight on the centering
-            bindex = bindex[0:max_num]
-            det = det[bindex, :]
-            if kpss is not None:
-                kpss = kpss[bindex, :]
-        return det, kpss
-
-    def nms(self, dets):
-        thresh = self.nms_thresh
-        x1 = dets[:, 0]
-        y1 = dets[:, 1]
-        x2 = dets[:, 2]
-        y2 = dets[:, 3]
-        scores = dets[:, 4]
-
-        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-        order = scores.argsort()[::-1]
-
-        keep = []
-        while order.size > 0:
-            i = order[0]
-            keep.append(i)
-            xx1 = np.maximum(x1[i], x1[order[1:]])
-            yy1 = np.maximum(y1[i], y1[order[1:]])
-            xx2 = np.minimum(x2[i], x2[order[1:]])
-            yy2 = np.minimum(y2[i], y2[order[1:]])
-
-            w = np.maximum(0.0, xx2 - xx1 + 1)
-            h = np.maximum(0.0, yy2 - yy1 + 1)
-            inter = w * h
-            ovr = inter / (areas[i] + areas[order[1:]] - inter)
-
-            inds = np.where(ovr <= thresh)[0]
-            order = order[inds + 1]
-
-        return keep
-
-def get_retinaface(name, download=False, root='~/.insightface/models', **kwargs):
-    if not download:
-        assert os.path.exists(name)
-        return RetinaFace(name)
-    else:
-        from .model_store import get_model_file
-        _file = get_model_file("retinaface_%s" % name, root=root)
-        return retinaface(_file)
-
-

insightface/model_zoo/scrfd.py

@@ -1,348 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Organization  : insightface.ai
-# @Author        : Jia Guo
-# @Time          : 2021-05-04
-# @Function      : 
-
-from __future__ import division
-import datetime
-import numpy as np
-import onnx
-import onnxruntime
-import os
-import os.path as osp
-import cv2
-import sys
-
-def softmax(z):
-    assert len(z.shape) == 2
-    s = np.max(z, axis=1)
-    s = s[:, np.newaxis] # necessary step to do broadcasting
-    e_x = np.exp(z - s)
-    div = np.sum(e_x, axis=1)
-    div = div[:, np.newaxis] # dito
-    return e_x / div
-
-def distance2bbox(points, distance, max_shape=None):
-    """Decode distance prediction to bounding box.
-
-    Args:
-        points (Tensor): Shape (n, 2), [x, y].
-        distance (Tensor): Distance from the given point to 4
-            boundaries (left, top, right, bottom).
-        max_shape (tuple): Shape of the image.
-
-    Returns:
-        Tensor: Decoded bboxes.
-    """
-    x1 = points[:, 0] - distance[:, 0]
-    y1 = points[:, 1] - distance[:, 1]
-    x2 = points[:, 0] + distance[:, 2]
-    y2 = points[:, 1] + distance[:, 3]
-    if max_shape is not None:
-        x1 = x1.clamp(min=0, max=max_shape[1])
-        y1 = y1.clamp(min=0, max=max_shape[0])
-        x2 = x2.clamp(min=0, max=max_shape[1])
-        y2 = y2.clamp(min=0, max=max_shape[0])
-    return np.stack([x1, y1, x2, y2], axis=-1)
-
-def distance2kps(points, distance, max_shape=None):
-    """Decode distance prediction to bounding box.
-
-    Args:
-        points (Tensor): Shape (n, 2), [x, y].
-        distance (Tensor): Distance from the given point to 4
-            boundaries (left, top, right, bottom).
-        max_shape (tuple): Shape of the image.
-
-    Returns:
-        Tensor: Decoded bboxes.
-    """
-    preds = []
-    for i in range(0, distance.shape[1], 2):
-        px = points[:, i%2] + distance[:, i]
-        py = points[:, i%2+1] + distance[:, i+1]
-        if max_shape is not None:
-            px = px.clamp(min=0, max=max_shape[1])
-            py = py.clamp(min=0, max=max_shape[0])
-        preds.append(px)
-        preds.append(py)
-    return np.stack(preds, axis=-1)
-
-class SCRFD:
-    def __init__(self, model_file=None, session=None):
-        import onnxruntime
-        self.model_file = model_file
-        self.session = session
-        self.taskname = 'detection'
-        self.batched = False
-        if self.session is None:
-            assert self.model_file is not None
-            assert osp.exists(self.model_file)
-            self.session = onnxruntime.InferenceSession(self.model_file, None)
-        self.center_cache = {}
-        self.nms_thresh = 0.4
-        self.det_thresh = 0.5
-        self._init_vars()
-
-    def _init_vars(self):
-        input_cfg = self.session.get_inputs()[0]
-        input_shape = input_cfg.shape
-        #print(input_shape)
-        if isinstance(input_shape[2], str):
-            self.input_size = None
-        else:
-            self.input_size = tuple(input_shape[2:4][::-1])
-        #print('image_size:', self.image_size)
-        input_name = input_cfg.name
-        self.input_shape = input_shape
-        outputs = self.session.get_outputs()
-        if len(outputs[0].shape) == 3:
-            self.batched = True
-        output_names = []
-        for o in outputs:
-            output_names.append(o.name)
-        self.input_name = input_name
-        self.output_names = output_names
-        self.input_mean = 127.5
-        self.input_std = 128.0
-        #print(self.output_names)
-        #assert len(outputs)==10 or len(outputs)==15
-        self.use_kps = False
-        self._anchor_ratio = 1.0
-        self._num_anchors = 1
-        if len(outputs)==6:
-            self.fmc = 3
-            self._feat_stride_fpn = [8, 16, 32]
-            self._num_anchors = 2
-        elif len(outputs)==9:
-            self.fmc = 3
-            self._feat_stride_fpn = [8, 16, 32]
-            self._num_anchors = 2
-            self.use_kps = True
-        elif len(outputs)==10:
-            self.fmc = 5
-            self._feat_stride_fpn = [8, 16, 32, 64, 128]
-            self._num_anchors = 1
-        elif len(outputs)==15:
-            self.fmc = 5
-            self._feat_stride_fpn = [8, 16, 32, 64, 128]
-            self._num_anchors = 1
-            self.use_kps = True
-
-    def prepare(self, ctx_id, **kwargs):
-        if ctx_id<0:
-            self.session.set_providers(['CPUExecutionProvider'])
-        nms_thresh = kwargs.get('nms_thresh', None)
-        if nms_thresh is not None:
-            self.nms_thresh = nms_thresh
-        det_thresh = kwargs.get('det_thresh', None)
-        if det_thresh is not None:
-            self.det_thresh = det_thresh
-        input_size = kwargs.get('input_size', None)
-        if input_size is not None:
-            if self.input_size is not None:
-                print('warning: det_size is already set in scrfd model, ignore')
-            else:
-                self.input_size = input_size
-
-    def forward(self, img, threshold):
-        scores_list = []
-        bboxes_list = []
-        kpss_list = []
-        input_size = tuple(img.shape[0:2][::-1])
-        blob = cv2.dnn.blobFromImage(img, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
-        net_outs = self.session.run(self.output_names, {self.input_name : blob})
-
-        input_height = blob.shape[2]
-        input_width = blob.shape[3]
-        fmc = self.fmc
-        for idx, stride in enumerate(self._feat_stride_fpn):
-            # If model support batch dim, take first output
-            if self.batched:
-                scores = net_outs[idx][0]
-                bbox_preds = net_outs[idx + fmc][0]
-                bbox_preds = bbox_preds * stride
-                if self.use_kps:
-                    kps_preds = net_outs[idx + fmc * 2][0] * stride
-            # If model doesn't support batching take output as is
-            else:
-                scores = net_outs[idx]
-                bbox_preds = net_outs[idx + fmc]
-                bbox_preds = bbox_preds * stride
-                if self.use_kps:
-                    kps_preds = net_outs[idx + fmc * 2] * stride
-
-            height = input_height // stride
-            width = input_width // stride
-            K = height * width
-            key = (height, width, stride)
-            if key in self.center_cache:
-                anchor_centers = self.center_cache[key]
-            else:
-                #solution-1, c style:
-                #anchor_centers = np.zeros( (height, width, 2), dtype=np.float32 )
-                #for i in range(height):
-                #    anchor_centers[i, :, 1] = i
-                #for i in range(width):
-                #    anchor_centers[:, i, 0] = i
-
-                #solution-2:
-                #ax = np.arange(width, dtype=np.float32)
-                #ay = np.arange(height, dtype=np.float32)
-                #xv, yv = np.meshgrid(np.arange(width), np.arange(height))
-                #anchor_centers = np.stack([xv, yv], axis=-1).astype(np.float32)
-
-                #solution-3:
-                anchor_centers = np.stack(np.mgrid[:height, :width][::-1], axis=-1).astype(np.float32)
-                #print(anchor_centers.shape)
-
-                anchor_centers = (anchor_centers * stride).reshape( (-1, 2) )
-                if self._num_anchors>1:
-                    anchor_centers = np.stack([anchor_centers]*self._num_anchors, axis=1).reshape( (-1,2) )
-                if len(self.center_cache)<100:
-                    self.center_cache[key] = anchor_centers
-
-            pos_inds = np.where(scores>=threshold)[0]
-            bboxes = distance2bbox(anchor_centers, bbox_preds)
-            pos_scores = scores[pos_inds]
-            pos_bboxes = bboxes[pos_inds]
-            scores_list.append(pos_scores)
-            bboxes_list.append(pos_bboxes)
-            if self.use_kps:
-                kpss = distance2kps(anchor_centers, kps_preds)
-                #kpss = kps_preds
-                kpss = kpss.reshape( (kpss.shape[0], -1, 2) )
-                pos_kpss = kpss[pos_inds]
-                kpss_list.append(pos_kpss)
-        return scores_list, bboxes_list, kpss_list
-
-    def detect(self, img, input_size = None, max_num=0, metric='default'):
-        assert input_size is not None or self.input_size is not None
-        input_size = self.input_size if input_size is None else input_size
-            
-        im_ratio = float(img.shape[0]) / img.shape[1]
-        model_ratio = float(input_size[1]) / input_size[0]
-        if im_ratio>model_ratio:
-            new_height = input_size[1]
-            new_width = int(new_height / im_ratio)
-        else:
-            new_width = input_size[0]
-            new_height = int(new_width * im_ratio)
-        det_scale = float(new_height) / img.shape[0]
-        resized_img = cv2.resize(img, (new_width, new_height))
-        det_img = np.zeros( (input_size[1], input_size[0], 3), dtype=np.uint8 )
-        det_img[:new_height, :new_width, :] = resized_img
-
-        scores_list, bboxes_list, kpss_list = self.forward(det_img, self.det_thresh)
-
-        scores = np.vstack(scores_list)
-        scores_ravel = scores.ravel()
-        order = scores_ravel.argsort()[::-1]
-        bboxes = np.vstack(bboxes_list) / det_scale
-        if self.use_kps:
-            kpss = np.vstack(kpss_list) / det_scale
-        pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False)
-        pre_det = pre_det[order, :]
-        keep = self.nms(pre_det)
-        det = pre_det[keep, :]
-        if self.use_kps:
-            kpss = kpss[order,:,:]
-            kpss = kpss[keep,:,:]
-        else:
-            kpss = None
-        if max_num > 0 and det.shape[0] > max_num:
-            area = (det[:, 2] - det[:, 0]) * (det[:, 3] -
-                                                    det[:, 1])
-            img_center = img.shape[0] // 2, img.shape[1] // 2
-            offsets = np.vstack([
-                (det[:, 0] + det[:, 2]) / 2 - img_center[1],
-                (det[:, 1] + det[:, 3]) / 2 - img_center[0]
-            ])
-            offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
-            if metric=='max':
-                values = area
-            else:
-                values = area - offset_dist_squared * 2.0  # some extra weight on the centering
-            bindex = np.argsort(
-                values)[::-1]  # some extra weight on the centering
-            bindex = bindex[0:max_num]
-            det = det[bindex, :]
-            if kpss is not None:
-                kpss = kpss[bindex, :]
-        return det, kpss
-
-    def nms(self, dets):
-        thresh = self.nms_thresh
-        x1 = dets[:, 0]
-        y1 = dets[:, 1]
-        x2 = dets[:, 2]
-        y2 = dets[:, 3]
-        scores = dets[:, 4]
-
-        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-        order = scores.argsort()[::-1]
-
-        keep = []
-        while order.size > 0:
-            i = order[0]
-            keep.append(i)
-            xx1 = np.maximum(x1[i], x1[order[1:]])
-            yy1 = np.maximum(y1[i], y1[order[1:]])
-            xx2 = np.minimum(x2[i], x2[order[1:]])
-            yy2 = np.minimum(y2[i], y2[order[1:]])
-
-            w = np.maximum(0.0, xx2 - xx1 + 1)
-            h = np.maximum(0.0, yy2 - yy1 + 1)
-            inter = w * h
-            ovr = inter / (areas[i] + areas[order[1:]] - inter)
-
-            inds = np.where(ovr <= thresh)[0]
-            order = order[inds + 1]
-
-        return keep
-
-def get_scrfd(name, download=False, root='~/.insightface/models', **kwargs):
-    if not download:
-        assert os.path.exists(name)
-        return SCRFD(name)
-    else:
-        from .model_store import get_model_file
-        _file = get_model_file("scrfd_%s" % name, root=root)
-        return SCRFD(_file)
-
-
-def scrfd_2p5gkps(**kwargs):
-    return get_scrfd("2p5gkps", download=True, **kwargs)
-
-
-if __name__ == '__main__':
-    import glob
-    detector = SCRFD(model_file='./det.onnx')
-    detector.prepare(-1)
-    img_paths = ['tests/data/t1.jpg']
-    for img_path in img_paths:
-        img = cv2.imread(img_path)
-
-        for _ in range(1):
-            ta = datetime.datetime.now()
-            #bboxes, kpss = detector.detect(img, 0.5, input_size = (640, 640))
-            bboxes, kpss = detector.detect(img, 0.5)
-            tb = datetime.datetime.now()
-            print('all cost:', (tb-ta).total_seconds()*1000)
-        print(img_path, bboxes.shape)
-        if kpss is not None:
-            print(kpss.shape)
-        for i in range(bboxes.shape[0]):
-            bbox = bboxes[i]
-            x1,y1,x2,y2,score = bbox.astype(np.int)
-            cv2.rectangle(img, (x1,y1)  , (x2,y2) , (255,0,0) , 2)
-            if kpss is not None:
-                kps = kpss[i]
-                for kp in kps:
-                    kp = kp.astype(np.int)
-                    cv2.circle(img, tuple(kp) , 1, (0,0,255) , 2)
-        filename = img_path.split('/')[-1]
-        print('output:', filename)
-        cv2.imwrite('./outputs/%s'%filename, img)
-

insightface/thirdparty/face3d/__init__.py

@@ -1,4 +0,0 @@
-#import mesh
-#import morphable_model
-from . import mesh
-from . import morphable_model

insightface/thirdparty/face3d/mesh/__init__.py

@@ -1,15 +0,0 @@
-#from __future__ import absolute_import
-#from cython import mesh_core_cython
-#import io
-#import vis
-#import transform
-#import light
-#import render
-
-from .cython import mesh_core_cython
-from . import io
-from . import vis
-from . import transform
-from . import light
-from . import render
-

insightface/thirdparty/face3d/mesh/cython/mesh_core.cpp

@@ -1,375 +0,0 @@
-/*
-functions that can not be optimazed by vertorization in python.
-1. rasterization.(need process each triangle)
-2. normal of each vertex.(use one-ring, need process each vertex)
-3. write obj(seems that it can be verctorized? anyway, writing it in c++ is simple, so also add function here. --> however, why writting in c++ is still slow?)
-
-Author: Yao Feng 
-Mail: yaofeng1995@gmail.com
-*/
-
-#include "mesh_core.h"
-
-
-/* Judge whether the point is in the triangle
-Method:
-    http://blackpawn.com/texts/pointinpoly/
-Args:
-    point: [x, y] 
-    tri_points: three vertices(2d points) of a triangle. 2 coords x 3 vertices
-Returns:
-    bool: true for in triangle
-*/
-bool isPointInTri(point p, point p0, point p1, point p2)
-{   
-    // vectors
-    point v0, v1, v2;
-    v0 = p2 - p0;
-    v1 = p1 - p0;
-    v2 = p - p0;
-
-    // dot products
-    float dot00 = v0.dot(v0); //v0.x * v0.x + v0.y * v0.y //np.dot(v0.T, v0)
-    float dot01 = v0.dot(v1); //v0.x * v1.x + v0.y * v1.y //np.dot(v0.T, v1)
-    float dot02 = v0.dot(v2); //v0.x * v2.x + v0.y * v2.y //np.dot(v0.T, v2)
-    float dot11 = v1.dot(v1); //v1.x * v1.x + v1.y * v1.y //np.dot(v1.T, v1)
-    float dot12 = v1.dot(v2); //v1.x * v2.x + v1.y * v2.y//np.dot(v1.T, v2)
-
-    // barycentric coordinates
-    float inverDeno;
-    if(dot00*dot11 - dot01*dot01 == 0)
-        inverDeno = 0;
-    else
-        inverDeno = 1/(dot00*dot11 - dot01*dot01);
-
-    float u = (dot11*dot02 - dot01*dot12)*inverDeno;
-    float v = (dot00*dot12 - dot01*dot02)*inverDeno;
-
-    // check if point in triangle
-    return (u >= 0) && (v >= 0) && (u + v < 1);
-}
-
-
-void get_point_weight(float* weight, point p, point p0, point p1, point p2)
-{   
-    // vectors
-    point v0, v1, v2;
-    v0 = p2 - p0; 
-    v1 = p1 - p0; 
-    v2 = p - p0; 
-
-    // dot products
-    float dot00 = v0.dot(v0); //v0.x * v0.x + v0.y * v0.y //np.dot(v0.T, v0)
-    float dot01 = v0.dot(v1); //v0.x * v1.x + v0.y * v1.y //np.dot(v0.T, v1)
-    float dot02 = v0.dot(v2); //v0.x * v2.x + v0.y * v2.y //np.dot(v0.T, v2)
-    float dot11 = v1.dot(v1); //v1.x * v1.x + v1.y * v1.y //np.dot(v1.T, v1)
-    float dot12 = v1.dot(v2); //v1.x * v2.x + v1.y * v2.y//np.dot(v1.T, v2)
-
-    // barycentric coordinates
-    float inverDeno;
-    if(dot00*dot11 - dot01*dot01 == 0)
-        inverDeno = 0;
-    else
-        inverDeno = 1/(dot00*dot11 - dot01*dot01);
-
-    float u = (dot11*dot02 - dot01*dot12)*inverDeno;
-    float v = (dot00*dot12 - dot01*dot02)*inverDeno;
-
-    // weight
-    weight[0] = 1 - u - v;
-    weight[1] = v;
-    weight[2] = u;
-}
-
-
-void _get_normal_core(
-    float* normal, float* tri_normal, int* triangles,
-    int ntri)
-{
-    int i, j;
-    int tri_p0_ind, tri_p1_ind, tri_p2_ind;
-
-    for(i = 0; i < ntri; i++)
-    {
-        tri_p0_ind = triangles[3*i];
-        tri_p1_ind = triangles[3*i + 1];
-        tri_p2_ind = triangles[3*i + 2];
-
-        for(j = 0; j < 3; j++)
-        {
-            normal[3*tri_p0_ind + j] = normal[3*tri_p0_ind + j] + tri_normal[3*i + j];
-            normal[3*tri_p1_ind + j] = normal[3*tri_p1_ind + j] + tri_normal[3*i + j];
-            normal[3*tri_p2_ind + j] = normal[3*tri_p2_ind + j] + tri_normal[3*i + j];
-        }
-    }
-}
-
-
-void _rasterize_triangles_core(
-    float* vertices, int* triangles, 
-    float* depth_buffer, int* triangle_buffer, float* barycentric_weight,
-    int nver, int ntri,
-    int h, int w)
-{
-    int i;
-    int x, y, k;
-    int tri_p0_ind, tri_p1_ind, tri_p2_ind;
-    point p0, p1, p2, p;
-    int x_min, x_max, y_min, y_max;
-    float p_depth, p0_depth, p1_depth, p2_depth;
-    float weight[3];
-
-    for(i = 0; i < ntri; i++)
-    {
-        tri_p0_ind = triangles[3*i];
-        tri_p1_ind = triangles[3*i + 1];
-        tri_p2_ind = triangles[3*i + 2];
-
-        p0.x = vertices[3*tri_p0_ind]; p0.y = vertices[3*tri_p0_ind + 1]; p0_depth = vertices[3*tri_p0_ind + 2];
-        p1.x = vertices[3*tri_p1_ind]; p1.y = vertices[3*tri_p1_ind + 1]; p1_depth = vertices[3*tri_p1_ind + 2];
-        p2.x = vertices[3*tri_p2_ind]; p2.y = vertices[3*tri_p2_ind + 1]; p2_depth = vertices[3*tri_p2_ind + 2];
-        
-        x_min = max((int)ceil(min(p0.x, min(p1.x, p2.x))), 0);
-        x_max = min((int)floor(max(p0.x, max(p1.x, p2.x))), w - 1);
-      
-        y_min = max((int)ceil(min(p0.y, min(p1.y, p2.y))), 0);
-        y_max = min((int)floor(max(p0.y, max(p1.y, p2.y))), h - 1);
-
-        if(x_max < x_min || y_max < y_min)
-        {
-            continue;
-        }
-
-        for(y = y_min; y <= y_max; y++) //h
-        {
-            for(x = x_min; x <= x_max; x++) //w
-            {
-                p.x = x; p.y = y;
-                if(p.x < 2 || p.x > w - 3 || p.y < 2 || p.y > h - 3 || isPointInTri(p, p0, p1, p2))
-                {
-                    get_point_weight(weight, p, p0, p1, p2);
-                    p_depth = weight[0]*p0_depth + weight[1]*p1_depth + weight[2]*p2_depth;
-
-                    if((p_depth > depth_buffer[y*w + x]))
-                    {
-                        depth_buffer[y*w + x] = p_depth;
-                        triangle_buffer[y*w + x] = i;
-                        for(k = 0; k < 3; k++)
-                        {
-                            barycentric_weight[y*w*3 + x*3 + k] = weight[k];
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-void _render_colors_core(
-    float* image, float* vertices, int* triangles, 
-    float* colors, 
-    float* depth_buffer,
-    int nver, int ntri,
-    int h, int w, int c)
-{
-    int i;
-    int x, y, k;
-    int tri_p0_ind, tri_p1_ind, tri_p2_ind;
-    point p0, p1, p2, p;
-    int x_min, x_max, y_min, y_max;
-    float p_depth, p0_depth, p1_depth, p2_depth;
-    float p_color, p0_color, p1_color, p2_color;
-    float weight[3];
-
-    for(i = 0; i < ntri; i++)
-    {
-        tri_p0_ind = triangles[3*i];
-        tri_p1_ind = triangles[3*i + 1];
-        tri_p2_ind = triangles[3*i + 2];
-
-        p0.x = vertices[3*tri_p0_ind]; p0.y = vertices[3*tri_p0_ind + 1]; p0_depth = vertices[3*tri_p0_ind + 2];
-        p1.x = vertices[3*tri_p1_ind]; p1.y = vertices[3*tri_p1_ind + 1]; p1_depth = vertices[3*tri_p1_ind + 2];
-        p2.x = vertices[3*tri_p2_ind]; p2.y = vertices[3*tri_p2_ind + 1]; p2_depth = vertices[3*tri_p2_ind + 2];
-        
-        x_min = max((int)ceil(min(p0.x, min(p1.x, p2.x))), 0);
-        x_max = min((int)floor(max(p0.x, max(p1.x, p2.x))), w - 1);
-      
-        y_min = max((int)ceil(min(p0.y, min(p1.y, p2.y))), 0);
-        y_max = min((int)floor(max(p0.y, max(p1.y, p2.y))), h - 1);
-
-        if(x_max < x_min || y_max < y_min)
-        {
-            continue;
-        }
-
-        for(y = y_min; y <= y_max; y++) //h
-        {
-            for(x = x_min; x <= x_max; x++) //w
-            {
-                p.x = x; p.y = y;
-                if(p.x < 2 || p.x > w - 3 || p.y < 2 || p.y > h - 3 || isPointInTri(p, p0, p1, p2))
-                {
-                    get_point_weight(weight, p, p0, p1, p2);
-                    p_depth = weight[0]*p0_depth + weight[1]*p1_depth + weight[2]*p2_depth;
-
-                    if((p_depth > depth_buffer[y*w + x]))
-                    {
-                        for(k = 0; k < c; k++) // c
-                        {   
-                            p0_color = colors[c*tri_p0_ind + k];
-                            p1_color = colors[c*tri_p1_ind + k];
-                            p2_color = colors[c*tri_p2_ind + k]; 
-
-                            p_color = weight[0]*p0_color + weight[1]*p1_color + weight[2]*p2_color;
-                            image[y*w*c + x*c + k] = p_color;
-                        }
-
-                        depth_buffer[y*w + x] = p_depth;
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-void _render_texture_core(
-    float* image, float* vertices, int* triangles, 
-    float* texture, float* tex_coords, int* tex_triangles, 
-    float* depth_buffer,
-    int nver, int tex_nver, int ntri, 
-    int h, int w, int c, 
-    int tex_h, int tex_w, int tex_c, 
-    int mapping_type)
-{
-    int i;
-    int x, y, k;
-    int tri_p0_ind, tri_p1_ind, tri_p2_ind;
-    int tex_tri_p0_ind, tex_tri_p1_ind, tex_tri_p2_ind;
-    point p0, p1, p2, p;
-    point tex_p0, tex_p1, tex_p2, tex_p;
-    int x_min, x_max, y_min, y_max;
-    float weight[3];
-    float p_depth, p0_depth, p1_depth, p2_depth;
-    float xd, yd;
-    float ul, ur, dl, dr;
-    for(i = 0; i < ntri; i++)
-    {
-        // mesh
-        tri_p0_ind = triangles[3*i];
-        tri_p1_ind = triangles[3*i + 1];
-        tri_p2_ind = triangles[3*i + 2];
-
-        p0.x = vertices[3*tri_p0_ind]; p0.y = vertices[3*tri_p0_ind + 1]; p0_depth = vertices[3*tri_p0_ind + 2];
-        p1.x = vertices[3*tri_p1_ind]; p1.y = vertices[3*tri_p1_ind + 1]; p1_depth = vertices[3*tri_p1_ind + 2];
-        p2.x = vertices[3*tri_p2_ind]; p2.y = vertices[3*tri_p2_ind + 1]; p2_depth = vertices[3*tri_p2_ind + 2];
-       
-        // texture
-        tex_tri_p0_ind = tex_triangles[3*i];
-        tex_tri_p1_ind = tex_triangles[3*i + 1];
-        tex_tri_p2_ind = tex_triangles[3*i + 2];
-
-        tex_p0.x = tex_coords[3*tex_tri_p0_ind]; tex_p0.y = tex_coords[3*tri_p0_ind + 1];
-        tex_p1.x = tex_coords[3*tex_tri_p1_ind]; tex_p1.y = tex_coords[3*tri_p1_ind + 1];
-        tex_p2.x = tex_coords[3*tex_tri_p2_ind]; tex_p2.y = tex_coords[3*tri_p2_ind + 1];
-
-
-        x_min = max((int)ceil(min(p0.x, min(p1.x, p2.x))), 0);
-        x_max = min((int)floor(max(p0.x, max(p1.x, p2.x))), w - 1);
-      
-        y_min = max((int)ceil(min(p0.y, min(p1.y, p2.y))), 0);
-        y_max = min((int)floor(max(p0.y, max(p1.y, p2.y))), h - 1);
-
-
-        if(x_max < x_min || y_max < y_min)
-        {
-            continue;
-        }
-
-        for(y = y_min; y <= y_max; y++) //h
-        {
-            for(x = x_min; x <= x_max; x++) //w
-            {
-                p.x = x; p.y = y;
-                if(p.x < 2 || p.x > w - 3 || p.y < 2 || p.y > h - 3 || isPointInTri(p, p0, p1, p2))
-                {
-                    get_point_weight(weight, p, p0, p1, p2);
-                    p_depth = weight[0]*p0_depth + weight[1]*p1_depth + weight[2]*p2_depth;
-                    
-                    if((p_depth > depth_buffer[y*w + x]))
-                    {
-                        // -- color from texture
-                        // cal weight in mesh tri
-                        get_point_weight(weight, p, p0, p1, p2);
-                        // cal coord in texture
-                        tex_p = tex_p0*weight[0] + tex_p1*weight[1] + tex_p2*weight[2];
-                        tex_p.x = max(min(tex_p.x, float(tex_w - 1)), float(0)); 
-                        tex_p.y = max(min(tex_p.y, float(tex_h - 1)), float(0)); 
-
-                        yd = tex_p.y - floor(tex_p.y);
-                        xd = tex_p.x - floor(tex_p.x);
-                        for(k = 0; k < c; k++)
-                        {
-                            if(mapping_type==0)// nearest
-                            {   
-                                image[y*w*c + x*c + k] = texture[int(round(tex_p.y))*tex_w*tex_c + int(round(tex_p.x))*tex_c + k];
-                            }
-                            else//bilinear interp
-                            { 
-                                ul = texture[(int)floor(tex_p.y)*tex_w*tex_c + (int)floor(tex_p.x)*tex_c + k];
-                                ur = texture[(int)floor(tex_p.y)*tex_w*tex_c + (int)ceil(tex_p.x)*tex_c + k];
-                                dl = texture[(int)ceil(tex_p.y)*tex_w*tex_c + (int)floor(tex_p.x)*tex_c + k];
-                                dr = texture[(int)ceil(tex_p.y)*tex_w*tex_c + (int)ceil(tex_p.x)*tex_c + k];
-
-                                image[y*w*c + x*c + k] = ul*(1-xd)*(1-yd) + ur*xd*(1-yd) + dl*(1-xd)*yd + dr*xd*yd;
-                            }
-
-                        }
-
-                        depth_buffer[y*w + x] = p_depth;
-                    } 
-                }
-            }
-        }
-    }
-}
-
-
-
-// ------------------------------------------------- write
-// obj write
-// Ref: https://github.com/patrikhuber/eos/blob/master/include/eos/core/Mesh.hpp
-void _write_obj_with_colors_texture(string filename, string mtl_name, 
-    float* vertices, int* triangles, float* colors, float* uv_coords,
-    int nver, int ntri, int ntexver)
-{
-    int i;
-
-    ofstream obj_file(filename.c_str());
-
-    // first line of the obj file: the mtl name
-    obj_file << "mtllib " << mtl_name << endl;
-    
-    // write vertices 
-    for (i = 0; i < nver; ++i) 
-    {
-        obj_file << "v " << vertices[3*i] << " " << vertices[3*i + 1] << " " << vertices[3*i + 2] << colors[3*i] << " " << colors[3*i + 1] << " " << colors[3*i + 2] <<  endl;
-    }
-
-    // write uv coordinates
-    for (i = 0; i < ntexver; ++i) 
-    {
-        //obj_file << "vt " << uv_coords[2*i] << " " << (1 - uv_coords[2*i + 1]) << endl;
-        obj_file << "vt " << uv_coords[2*i] << " " << uv_coords[2*i + 1] << endl;
-    }
-
-    obj_file << "usemtl FaceTexture" << endl;
-    // write triangles
-    for (i = 0; i < ntri; ++i) 
-    {
-        // obj_file << "f " << triangles[3*i] << "/" << triangles[3*i] << " " << triangles[3*i + 1] << "/" << triangles[3*i + 1] << " " << triangles[3*i + 2] << "/" << triangles[3*i + 2] << endl;
-        obj_file << "f " << triangles[3*i + 2] << "/" << triangles[3*i + 2] << " " << triangles[3*i + 1] << "/" << triangles[3*i + 1] << " " << triangles[3*i] << "/" << triangles[3*i] << endl;
-    }
-
-}

insightface/thirdparty/face3d/mesh/cython/mesh_core.h

@@ -1,83 +0,0 @@
-#ifndef MESH_CORE_HPP_
-#define MESH_CORE_HPP_
-
-#include <stdio.h>
-#include <cmath>
-#include <algorithm>  
-#include <string>
-#include <iostream>
-#include <fstream>
-
-using namespace std;
-
-class point
-{
- public:
-    float x;
-    float y;
-
-    float dot(point p)
-    {
-        return this->x * p.x + this->y * p.y;
-    }
-
-    point operator-(const point& p)
-    {
-        point np;
-        np.x = this->x - p.x;
-        np.y = this->y - p.y;
-        return np;
-    }
-
-    point operator+(const point& p)
-    {
-        point np;
-        np.x = this->x + p.x;
-        np.y = this->y + p.y;
-        return np;
-    }
-
-    point operator*(float s)
-    {
-        point np;
-        np.x = s * this->x;
-        np.y = s * this->y;
-        return np;
-    }
-}; 
-
-
-bool isPointInTri(point p, point p0, point p1, point p2, int h, int w);
-void get_point_weight(float* weight, point p, point p0, point p1, point p2);
-
-void _get_normal_core(
-    float* normal, float* tri_normal, int* triangles,
-    int ntri);
-
-void _rasterize_triangles_core(
-    float* vertices, int* triangles, 
-    float* depth_buffer, int* triangle_buffer, float* barycentric_weight,
-    int nver, int ntri,
-    int h, int w);
-
-void _render_colors_core(
-    float* image, float* vertices, int* triangles, 
-    float* colors, 
-    float* depth_buffer,
-    int nver, int ntri,
-    int h, int w, int c);
-
-void _render_texture_core(
-    float* image, float* vertices, int* triangles, 
-    float* texture, float* tex_coords, int* tex_triangles, 
-    float* depth_buffer,
-    int nver, int tex_nver, int ntri, 
-    int h, int w, int c, 
-    int tex_h, int tex_w, int tex_c, 
-    int mapping_type);
-
-void _write_obj_with_colors_texture(string filename, string mtl_name, 
-    float* vertices, int* triangles, float* colors, float* uv_coords,
-    int nver, int ntri, int ntexver);
-
-#endif

insightface/thirdparty/face3d/mesh/cython/mesh_core_cython.pyx

@@ -1,109 +0,0 @@
-import numpy as np
-cimport numpy as np
-from libcpp.string cimport string
-
-# use the Numpy-C-API from Cython
-np.import_array()
-
-# cdefine the signature of our c function
-cdef extern from "mesh_core.h":
-    void _rasterize_triangles_core(
-        float* vertices, int* triangles, 
-        float* depth_buffer, int* triangle_buffer, float* barycentric_weight,
-        int nver, int ntri,
-        int h, int w)
-
-    void _render_colors_core(
-        float* image, float* vertices, int* triangles, 
-        float* colors, 
-        float* depth_buffer,
-        int nver, int ntri,
-        int h, int w, int c)
-
-    void _render_texture_core(
-        float* image, float* vertices, int* triangles, 
-        float* texture, float* tex_coords, int* tex_triangles, 
-        float* depth_buffer,
-        int nver, int tex_nver, int ntri, 
-        int h, int w, int c, 
-        int tex_h, int tex_w, int tex_c, 
-        int mapping_type)
-
-    void _get_normal_core(
-        float* normal, float* tri_normal, int* triangles,
-        int ntri)
-
-    void _write_obj_with_colors_texture(string filename, string mtl_name, 
-        float* vertices, int* triangles, float* colors, float* uv_coords,
-        int nver, int ntri, int ntexver)
-
-def get_normal_core(np.ndarray[float, ndim=2, mode = "c"] normal not None, 
-                np.ndarray[float, ndim=2, mode = "c"] tri_normal not None, 
-                np.ndarray[int, ndim=2, mode="c"] triangles not None, 
-                int ntri
-                ):
-    _get_normal_core(
-        <float*> np.PyArray_DATA(normal), <float*> np.PyArray_DATA(tri_normal), <int*> np.PyArray_DATA(triangles),  
-        ntri)
-
-def rasterize_triangles_core(
-                np.ndarray[float, ndim=2, mode = "c"] vertices not None, 
-                np.ndarray[int, ndim=2, mode="c"] triangles not None, 
-                np.ndarray[float, ndim=2, mode = "c"] depth_buffer not None,
-                np.ndarray[int, ndim=2, mode = "c"] triangle_buffer not None,
-                np.ndarray[float, ndim=2, mode = "c"] barycentric_weight not None,
-                int nver, int ntri,
-                int h, int w
-                ):   
-    _rasterize_triangles_core(
-        <float*> np.PyArray_DATA(vertices), <int*> np.PyArray_DATA(triangles),  
-        <float*> np.PyArray_DATA(depth_buffer), <int*> np.PyArray_DATA(triangle_buffer), <float*> np.PyArray_DATA(barycentric_weight),
-        nver, ntri,
-        h, w)
-
-def render_colors_core(np.ndarray[float, ndim=3, mode = "c"] image not None, 
-                np.ndarray[float, ndim=2, mode = "c"] vertices not None, 
-                np.ndarray[int, ndim=2, mode="c"] triangles not None, 
-                np.ndarray[float, ndim=2, mode = "c"] colors not None, 
-                np.ndarray[float, ndim=2, mode = "c"] depth_buffer not None,
-                int nver, int ntri,
-                int h, int w, int c
-                ):   
-    _render_colors_core(
-        <float*> np.PyArray_DATA(image), <float*> np.PyArray_DATA(vertices), <int*> np.PyArray_DATA(triangles),  
-        <float*> np.PyArray_DATA(colors), 
-        <float*> np.PyArray_DATA(depth_buffer),
-        nver, ntri,
-        h, w, c)
-
-def render_texture_core(np.ndarray[float, ndim=3, mode = "c"] image not None, 
-                np.ndarray[float, ndim=2, mode = "c"] vertices not None, 
-                np.ndarray[int, ndim=2, mode="c"] triangles not None, 
-                np.ndarray[float, ndim=3, mode = "c"] texture not None, 
-                np.ndarray[float, ndim=2, mode = "c"] tex_coords not None, 
-                np.ndarray[int, ndim=2, mode="c"] tex_triangles not None, 
-                np.ndarray[float, ndim=2, mode = "c"] depth_buffer not None,
-                int nver, int tex_nver, int ntri,
-                int h, int w, int c,
-                int tex_h, int tex_w, int tex_c,
-                int mapping_type
-                ):   
-    _render_texture_core(
-        <float*> np.PyArray_DATA(image), <float*> np.PyArray_DATA(vertices), <int*> np.PyArray_DATA(triangles),  
-        <float*> np.PyArray_DATA(texture), <float*> np.PyArray_DATA(tex_coords), <int*> np.PyArray_DATA(tex_triangles),  
-        <float*> np.PyArray_DATA(depth_buffer),
-        nver, tex_nver, ntri,
-        h, w, c, 
-        tex_h, tex_w, tex_c, 
-        mapping_type)
-
-def write_obj_with_colors_texture_core(string filename, string mtl_name, 
-                np.ndarray[float, ndim=2, mode = "c"] vertices not None, 
-                np.ndarray[int, ndim=2, mode="c"] triangles not None, 
-                np.ndarray[float, ndim=2, mode = "c"] colors not None, 
-                np.ndarray[float, ndim=2, mode = "c"] uv_coords not None, 
-                int nver, int ntri, int ntexver
-                ):
-    _write_obj_with_colors_texture(filename, mtl_name, 
-        <float*> np.PyArray_DATA(vertices), <int*> np.PyArray_DATA(triangles), <float*> np.PyArray_DATA(colors), <float*> np.PyArray_DATA(uv_coords),
-        nver, ntri, ntexver)

insightface/thirdparty/face3d/mesh/cython/setup.py

@@ -1,20 +0,0 @@
-'''
-python setup.py build_ext -i
-to compile
-'''
-
-# setup.py
-from distutils.core import setup, Extension
-from Cython.Build import cythonize
-from Cython.Distutils import build_ext
-import numpy
-
-setup(
-	name = 'mesh_core_cython',
-    cmdclass={'build_ext': build_ext},
-    ext_modules=[Extension("mesh_core_cython",
-                 sources=["mesh_core_cython.pyx", "mesh_core.cpp"],
-                 language='c++',
-                 include_dirs=[numpy.get_include()])],
-)
-

insightface/thirdparty/face3d/mesh/io.cpp

@@ -1 +0,0 @@
-#error Do not use this file, it is the result of a failed Cython compilation.

insightface/thirdparty/face3d/mesh/io.py

@@ -1,142 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import os
-from skimage import io
-from time import time
-
-from .cython import mesh_core_cython
-
-## TODO
-## TODO: c++ version
-def read_obj(obj_name):
-	''' read mesh
-	'''
-	return 0
-
-# ------------------------- write
-def write_asc(path, vertices):
-    '''
-    Args:
-        vertices: shape = (nver, 3)
-    '''
-    if path.split('.')[-1] == 'asc':
-        np.savetxt(path, vertices)
-    else:
-        np.savetxt(path + '.asc', vertices)
-
-def write_obj_with_colors(obj_name, vertices, triangles, colors):
-    ''' Save 3D face model with texture represented by colors.
-    Args:
-        obj_name: str
-        vertices: shape = (nver, 3)
-        triangles: shape = (ntri, 3)
-        colors: shape = (nver, 3)
-    '''
-    triangles = triangles.copy()
-    triangles += 1 # meshlab start with 1
-    
-    if obj_name.split('.')[-1] != 'obj':
-        obj_name = obj_name + '.obj'
-        
-    # write obj
-    with open(obj_name, 'w') as f:
-        
-        # write vertices & colors
-        for i in range(vertices.shape[0]):
-            # s = 'v {} {} {} \n'.format(vertices[0,i], vertices[1,i], vertices[2,i])
-            s = 'v {} {} {} {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2], colors[i, 0], colors[i, 1], colors[i, 2])
-            f.write(s)
-
-        # write f: ver ind/ uv ind
-        [k, ntri] = triangles.shape
-        for i in range(triangles.shape[0]):
-            # s = 'f {} {} {}\n'.format(triangles[i, 0], triangles[i, 1], triangles[i, 2])
-            s = 'f {} {} {}\n'.format(triangles[i, 2], triangles[i, 1], triangles[i, 0])
-            f.write(s)
-
-## TODO: c++ version
-def write_obj_with_texture(obj_name, vertices, triangles, texture, uv_coords):
-    ''' Save 3D face model with texture represented by texture map.
-    Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp
-    Args:
-        obj_name: str
-        vertices: shape = (nver, 3)
-        triangles: shape = (ntri, 3)
-        texture: shape = (256,256,3)
-        uv_coords: shape = (nver, 3) max value<=1
-    '''
-    if obj_name.split('.')[-1] != 'obj':
-        obj_name = obj_name + '.obj'
-    mtl_name = obj_name.replace('.obj', '.mtl')
-    texture_name = obj_name.replace('.obj', '_texture.png')
-    
-    triangles = triangles.copy()
-    triangles += 1 # mesh lab start with 1
-    
-    # write obj
-    with open(obj_name, 'w') as f:
-        # first line: write mtlib(material library)
-        s = "mtllib {}\n".format(os.path.abspath(mtl_name))
-        f.write(s)
-
-        # write vertices
-        for i in range(vertices.shape[0]):
-            s = 'v {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2])
-            f.write(s)
-        
-        # write uv coords
-        for i in range(uv_coords.shape[0]):
-            s = 'vt {} {}\n'.format(uv_coords[i,0], 1 - uv_coords[i,1])
-            f.write(s)
-
-        f.write("usemtl FaceTexture\n")
-
-        # write f: ver ind/ uv ind
-        for i in range(triangles.shape[0]):
-            s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,2], triangles[i,2], triangles[i,1], triangles[i,1], triangles[i,0], triangles[i,0])
-            f.write(s)
-
-    # write mtl
-    with open(mtl_name, 'w') as f:
-        f.write("newmtl FaceTexture\n")
-        s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image
-        f.write(s)
-
-    # write texture as png
-    imsave(texture_name, texture)
-
-# c++ version
-def write_obj_with_colors_texture(obj_name, vertices, triangles, colors, texture, uv_coords):
-    ''' Save 3D face model with texture. 
-    Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp
-    Args:
-        obj_name: str
-        vertices: shape = (nver, 3)
-        triangles: shape = (ntri, 3)
-        colors: shape = (nver, 3)
-        texture: shape = (256,256,3)
-        uv_coords: shape = (nver, 3) max value<=1
-    '''
-    if obj_name.split('.')[-1] != 'obj':
-        obj_name = obj_name + '.obj'
-    mtl_name = obj_name.replace('.obj', '.mtl')
-    texture_name = obj_name.replace('.obj', '_texture.png')
-    
-    triangles = triangles.copy()
-    triangles += 1 # mesh lab start with 1
-    
-    # write obj
-    vertices, colors, uv_coords = vertices.astype(np.float32).copy(), colors.astype(np.float32).copy(), uv_coords.astype(np.float32).copy()
-    mesh_core_cython.write_obj_with_colors_texture_core(str.encode(obj_name), str.encode(os.path.abspath(mtl_name)), vertices, triangles, colors, uv_coords, vertices.shape[0], triangles.shape[0], uv_coords.shape[0])
-   
-    # write mtl
-    with open(mtl_name, 'w') as f:
-        f.write("newmtl FaceTexture\n")
-        s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image
-        f.write(s)
-
-    # write texture as png
-    io.imsave(texture_name, texture)

insightface/thirdparty/face3d/mesh/light.py

@@ -1,213 +0,0 @@
-'''
-Functions about lighting mesh(changing colors/texture of mesh).
-1. add light to colors/texture (shade each vertex)
-2. fit light according to colors/texture & image.
-'''
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-from .cython import mesh_core_cython
-
-def get_normal(vertices, triangles):
-    ''' calculate normal direction in each vertex
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-    Returns:
-        normal: [nver, 3]
-    '''
-    pt0 = vertices[triangles[:, 0], :] # [ntri, 3]
-    pt1 = vertices[triangles[:, 1], :] # [ntri, 3]
-    pt2 = vertices[triangles[:, 2], :] # [ntri, 3]
-    tri_normal = np.cross(pt0 - pt1, pt0 - pt2) # [ntri, 3]. normal of each triangle
-
-    normal = np.zeros_like(vertices, dtype = np.float32).copy() # [nver, 3]
-    # for i in range(triangles.shape[0]):
-    #     normal[triangles[i, 0], :] = normal[triangles[i, 0], :] + tri_normal[i, :]
-    #     normal[triangles[i, 1], :] = normal[triangles[i, 1], :] + tri_normal[i, :]
-    #     normal[triangles[i, 2], :] = normal[triangles[i, 2], :] + tri_normal[i, :]
-    mesh_core_cython.get_normal_core(normal, tri_normal.astype(np.float32).copy(), triangles.copy(), triangles.shape[0])
-
-    # normalize to unit length
-    mag = np.sum(normal**2, 1) # [nver]
-    zero_ind = (mag == 0)
-    mag[zero_ind] = 1;
-    normal[zero_ind, 0] = np.ones((np.sum(zero_ind)))
-
-    normal = normal/np.sqrt(mag[:,np.newaxis])
-
-    return normal
-
-# TODO: test
-def add_light_sh(vertices, triangles, colors, sh_coeff):
-    ''' 
-    In 3d face, usually assume:
-    1. The surface of face is Lambertian(reflect only the low frequencies of lighting)
-    2. Lighting can be an arbitrary combination of point sources
-    --> can be expressed in terms of spherical harmonics(omit the lighting coefficients)
-    I = albedo * (sh(n) x sh_coeff)
-    
-    albedo: n x 1
-    sh_coeff: 9 x 1
-    Y(n) = (1, n_x, n_y, n_z, n_xn_y, n_xn_z, n_yn_z, n_x^2 - n_y^2, 3n_z^2 - 1)': n x 9 
-    # Y(n) = (1, n_x, n_y, n_z)': n x 4
-
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-        colors: [nver, 3] albedo
-        sh_coeff: [9, 1] spherical harmonics coefficients
-
-    Returns:
-        lit_colors: [nver, 3]
-    '''
-    assert vertices.shape[0] == colors.shape[0]
-    nver = vertices.shape[0]
-    normal = get_normal(vertices, triangles) # [nver, 3]
-    sh = np.array((np.ones(nver), n[:,0], n[:,1], n[:,2], n[:,0]*n[:,1], n[:,0]*n[:,2], n[:,1]*n[:,2], n[:,0]**2 - n[:,1]**2, 3*(n[:,2]**2) - 1)) # [nver, 9]
-    ref = sh.dot(sh_coeff) #[nver, 1]
-    lit_colors = colors*ref
-    return lit_colors
-
-
-def add_light(vertices, triangles, colors, light_positions = 0, light_intensities = 0):
-    ''' Gouraud shading. add point lights.
-    In 3d face, usually assume:
-    1. The surface of face is Lambertian(reflect only the low frequencies of lighting)
-    2. Lighting can be an arbitrary combination of point sources
-    3. No specular (unless skin is oil, 23333)
-
-    Ref: https://cs184.eecs.berkeley.edu/lecture/pipeline    
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-        light_positions: [nlight, 3] 
-        light_intensities: [nlight, 3]
-    Returns:
-        lit_colors: [nver, 3]
-    '''
-    nver = vertices.shape[0]
-    normals = get_normal(vertices, triangles) # [nver, 3]
-
-    # ambient
-    # La = ka*Ia
-
-    # diffuse
-    # Ld = kd*(I/r^2)max(0, nxl)
-    direction_to_lights = vertices[np.newaxis, :, :] - light_positions[:, np.newaxis, :] # [nlight, nver, 3]
-    direction_to_lights_n = np.sqrt(np.sum(direction_to_lights**2, axis = 2)) # [nlight, nver]
-    direction_to_lights = direction_to_lights/direction_to_lights_n[:, :, np.newaxis]
-    normals_dot_lights = normals[np.newaxis, :, :]*direction_to_lights # [nlight, nver, 3]
-    normals_dot_lights = np.sum(normals_dot_lights, axis = 2) # [nlight, nver]
-    diffuse_output = colors[np.newaxis, :, :]*normals_dot_lights[:, :, np.newaxis]*light_intensities[:, np.newaxis, :]
-    diffuse_output = np.sum(diffuse_output, axis = 0) # [nver, 3]
-    
-    # specular
-    # h = (v + l)/(|v + l|) bisector
-    # Ls = ks*(I/r^2)max(0, nxh)^p
-    # increasing p narrows the reflectionlob
-
-    lit_colors = diffuse_output # only diffuse part here.
-    lit_colors = np.minimum(np.maximum(lit_colors, 0), 1)
-    return lit_colors
-
-
-
-## TODO. estimate light(sh coeff)
-## -------------------------------- estimate. can not use now. 
-def fit_light(image, vertices, colors, triangles, vis_ind, lamb = 10, max_iter = 3):
-    [h, w, c] = image.shape
-
-    # surface normal
-    norm = get_normal(vertices, triangles)
-    
-    nver = vertices.shape[1]
-
-    # vertices --> corresponding image pixel
-    pt2d = vertices[:2, :]
-
-    pt2d[0,:] = np.minimum(np.maximum(pt2d[0,:], 0), w - 1)
-    pt2d[1,:] = np.minimum(np.maximum(pt2d[1,:], 0), h - 1)
-    pt2d = np.round(pt2d).astype(np.int32) # 2 x nver
-
-    image_pixel = image[pt2d[1,:], pt2d[0,:], :] # nver x 3
-    image_pixel = image_pixel.T # 3 x nver
-
-    # vertices --> corresponding mean texture pixel with illumination
-    # Spherical Harmonic Basis
-    harmonic_dim = 9
-    nx = norm[0,:];
-    ny = norm[1,:];
-    nz = norm[2,:];
-    harmonic = np.zeros((nver, harmonic_dim))
-
-    pi = np.pi
-    harmonic[:,0] = np.sqrt(1/(4*pi)) * np.ones((nver,));
-    harmonic[:,1] = np.sqrt(3/(4*pi)) * nx;
-    harmonic[:,2] = np.sqrt(3/(4*pi)) * ny;
-    harmonic[:,3] = np.sqrt(3/(4*pi)) * nz;
-    harmonic[:,4] = 1/2. * np.sqrt(3/(4*pi)) * (2*nz**2 - nx**2 - ny**2);
-    harmonic[:,5] = 3 * np.sqrt(5/(12*pi)) * (ny*nz);
-    harmonic[:,6] = 3 * np.sqrt(5/(12*pi)) * (nx*nz);
-    harmonic[:,7] = 3 * np.sqrt(5/(12*pi)) * (nx*ny);
-    harmonic[:,8] = 3/2. * np.sqrt(5/(12*pi)) * (nx*nx - ny*ny);
-    
-    '''
-    I' = sum(albedo * lj * hj) j = 0:9 (albedo = tex)
-    set A = albedo*h (n x 9)
-        alpha = lj (9 x 1)
-        Y = I (n x 1)
-        Y' = A.dot(alpha)
-
-    opt function:
-        ||Y - A*alpha|| + lambda*(alpha'*alpha)
-    result:
-        A'*(Y - A*alpha) + lambda*alpha = 0
-        ==>
-        (A'*A*alpha - lambda)*alpha = A'*Y
-        left: 9 x 9
-        right: 9 x 1
-    '''
-    n_vis_ind = len(vis_ind)
-    n = n_vis_ind*c
-
-    Y = np.zeros((n, 1))
-    A = np.zeros((n, 9))
-    light = np.zeros((3, 1))
-
-    for k in range(c):
-        Y[k*n_vis_ind:(k+1)*n_vis_ind, :] = image_pixel[k, vis_ind][:, np.newaxis]
-        A[k*n_vis_ind:(k+1)*n_vis_ind, :] = texture[k, vis_ind][:, np.newaxis] * harmonic[vis_ind, :]
-        Ac = texture[k, vis_ind][:, np.newaxis]
-        Yc = image_pixel[k, vis_ind][:, np.newaxis]
-        light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac))
-
-    for i in range(max_iter):
-
-        Yc = Y.copy()
-        for k in range(c):
-            Yc[k*n_vis_ind:(k+1)*n_vis_ind, :]  /= light[k]
-
-        # update alpha
-        equation_left = np.dot(A.T, A) + lamb*np.eye(harmonic_dim); # why + ?
-        equation_right = np.dot(A.T, Yc) 
-        alpha = np.dot(np.linalg.inv(equation_left), equation_right)
-
-        # update light
-        for k in range(c):
-            Ac = A[k*n_vis_ind:(k+1)*n_vis_ind, :].dot(alpha)
-            Yc = Y[k*n_vis_ind:(k+1)*n_vis_ind, :]
-            light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac))
-
-    appearance = np.zeros_like(texture)
-    for k in range(c):
-        tmp = np.dot(harmonic*texture[k, :][:, np.newaxis], alpha*light[k])
-        appearance[k,:] = tmp.T
-
-    appearance = np.minimum(np.maximum(appearance, 0), 1)
-
-    return appearance
-

insightface/thirdparty/face3d/mesh/render.py

@@ -1,135 +0,0 @@
-'''
-functions about rendering mesh(from 3d obj to 2d image).
-only use rasterization render here.
-Note that:
-1. Generally, render func includes camera, light, raterize. Here no camera and light(I write these in other files)
-2. Generally, the input vertices are normalized to [-1,1] and cetered on [0, 0]. (in world space)
-   Here, the vertices are using image coords, which centers on [w/2, h/2] with the y-axis pointing to oppisite direction.
- Means: render here only conducts interpolation.(I just want to make the input flexible)
-
-Author: Yao Feng 
-Mail: yaofeng1995@gmail.com
-'''
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-from time import time
-
-from .cython import mesh_core_cython
-
-def rasterize_triangles(vertices, triangles, h, w):
-    ''' 
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-        h: height
-        w: width
-    Returns:
-        depth_buffer: [h, w] saves the depth, here, the bigger the z, the fronter the point.
-        triangle_buffer: [h, w] saves the tri id(-1 for no triangle). 
-        barycentric_weight: [h, w, 3] saves corresponding barycentric weight.
-
-    # Each triangle has 3 vertices & Each vertex has 3 coordinates x, y, z.
-    # h, w is the size of rendering
-    '''
-
-    # initial 
-    depth_buffer = np.zeros([h, w]) - 999999. #set the initial z to the farest position
-    triangle_buffer = np.zeros([h, w], dtype = np.int32) - 1  # if tri id = -1, the pixel has no triangle correspondance
-    barycentric_weight = np.zeros([h, w, 3], dtype = np.float32)  # 
-    
-    vertices = vertices.astype(np.float32).copy()
-    triangles = triangles.astype(np.int32).copy()
-
-    mesh_core_cython.rasterize_triangles_core(
-                vertices, triangles,
-                depth_buffer, triangle_buffer, barycentric_weight, 
-                vertices.shape[0], triangles.shape[0], 
-                h, w)
-
-def render_colors(vertices, triangles, colors, h, w, c = 3, BG = None):
-    ''' render mesh with colors
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3] 
-        colors: [nver, 3]
-        h: height
-        w: width  
-        c: channel
-        BG: background image
-    Returns:
-        image: [h, w, c]. rendered image./rendering.
-    '''
-
-    # initial 
-    if BG is None:
-        image = np.zeros((h, w, c), dtype = np.float32)
-    else:
-        assert BG.shape[0] == h and BG.shape[1] == w and BG.shape[2] == c
-        image = BG
-    depth_buffer = np.zeros([h, w], dtype = np.float32, order = 'C') - 999999.
-
-    # change orders. --> C-contiguous order(column major)
-    vertices = vertices.astype(np.float32).copy()
-    triangles = triangles.astype(np.int32).copy()
-    colors = colors.astype(np.float32).copy()
-    ###
-    st = time()
-    mesh_core_cython.render_colors_core(
-                image, vertices, triangles,
-                colors,
-                depth_buffer,
-                vertices.shape[0], triangles.shape[0], 
-                h, w, c)
-    return image
-
-
-def render_texture(vertices, triangles, texture, tex_coords, tex_triangles, h, w, c = 3, mapping_type = 'nearest', BG = None):
-    ''' render mesh with texture map
-    Args:
-        vertices: [3, nver]
-        triangles: [3, ntri]
-        texture: [tex_h, tex_w, 3]
-        tex_coords: [ntexcoords, 3]
-        tex_triangles: [ntri, 3]
-        h: height of rendering
-        w: width of rendering
-        c: channel
-        mapping_type: 'bilinear' or 'nearest'
-    '''
-    # initial 
-    if BG is None:
-        image = np.zeros((h, w, c), dtype = np.float32)
-    else:
-        assert BG.shape[0] == h and BG.shape[1] == w and BG.shape[2] == c
-        image = BG
-
-    depth_buffer = np.zeros([h, w], dtype = np.float32, order = 'C') - 999999.
-    
-    tex_h, tex_w, tex_c = texture.shape
-    if mapping_type == 'nearest':
-        mt = int(0)
-    elif mapping_type == 'bilinear':
-        mt = int(1)
-    else:
-        mt = int(0)
-    
-    # -> C order
-    vertices = vertices.astype(np.float32).copy()
-    triangles = triangles.astype(np.int32).copy()
-    texture = texture.astype(np.float32).copy()
-    tex_coords = tex_coords.astype(np.float32).copy()
-    tex_triangles = tex_triangles.astype(np.int32).copy()
-
-    mesh_core_cython.render_texture_core(
-                image, vertices, triangles,
-                texture, tex_coords, tex_triangles,
-                depth_buffer,
-                vertices.shape[0], tex_coords.shape[0], triangles.shape[0], 
-                h, w, c,
-                tex_h, tex_w, tex_c,
-                mt)
-    return image
-

insightface/thirdparty/face3d/mesh/transform.py

@@ -1,383 +0,0 @@
-'''
-Functions about transforming mesh(changing the position: modify vertices).
-1. forward: transform(transform, camera, project).
-2. backward: estimate transform matrix from correspondences.
-
-Author: Yao Feng 
-Mail: yaofeng1995@gmail.com
-'''
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import math
-from math import cos, sin
-
-def angle2matrix(angles):
-    ''' get rotation matrix from three rotation angles(degree). right-handed.
-    Args:
-        angles: [3,]. x, y, z angles
-        x: pitch. positive for looking down.
-        y: yaw. positive for looking left. 
-        z: roll. positive for tilting head right. 
-    Returns:
-        R: [3, 3]. rotation matrix.
-    '''
-    x, y, z = np.deg2rad(angles[0]), np.deg2rad(angles[1]), np.deg2rad(angles[2])
-    # x
-    Rx=np.array([[1,      0,       0],
-                 [0, cos(x),  -sin(x)],
-                 [0, sin(x),   cos(x)]])
-    # y
-    Ry=np.array([[ cos(y), 0, sin(y)],
-                 [      0, 1,      0],
-                 [-sin(y), 0, cos(y)]])
-    # z
-    Rz=np.array([[cos(z), -sin(z), 0],
-                 [sin(z),  cos(z), 0],
-                 [     0,       0, 1]])
-    
-    R=Rz.dot(Ry.dot(Rx))
-    return R.astype(np.float32)
-
-def angle2matrix_3ddfa(angles):
-    ''' get rotation matrix from three rotation angles(radian). The same as in 3DDFA.
-    Args:
-        angles: [3,]. x, y, z angles
-        x: pitch.
-        y: yaw. 
-        z: roll. 
-    Returns:
-        R: 3x3. rotation matrix.
-    '''
-    # x, y, z = np.deg2rad(angles[0]), np.deg2rad(angles[1]), np.deg2rad(angles[2])
-    x, y, z = angles[0], angles[1], angles[2]
-    
-    # x
-    Rx=np.array([[1,      0,       0],
-                 [0, cos(x),  sin(x)],
-                 [0, -sin(x),   cos(x)]])
-    # y
-    Ry=np.array([[ cos(y), 0, -sin(y)],
-                 [      0, 1,      0],
-                 [sin(y), 0, cos(y)]])
-    # z
-    Rz=np.array([[cos(z), sin(z), 0],
-                 [-sin(z),  cos(z), 0],
-                 [     0,       0, 1]])
-    R = Rx.dot(Ry).dot(Rz)
-    return R.astype(np.float32)
-
-
-## ------------------------------------------ 1. transform(transform, project, camera).
-## ---------- 3d-3d transform. Transform obj in world space
-def rotate(vertices, angles):
-    ''' rotate vertices. 
-    X_new = R.dot(X). X: 3 x 1   
-    Args:
-        vertices: [nver, 3]. 
-        rx, ry, rz: degree angles
-        rx: pitch. positive for looking down 
-        ry: yaw. positive for looking left
-        rz: roll. positive for tilting head right
-    Returns:
-        rotated vertices: [nver, 3]
-    '''
-    R = angle2matrix(angles)
-    rotated_vertices = vertices.dot(R.T)
-
-    return rotated_vertices
-
-def similarity_transform(vertices, s, R, t3d):
-    ''' similarity transform. dof = 7.
-    3D: s*R.dot(X) + t
-    Homo: M = [[sR, t],[0^T, 1]].  M.dot(X)
-    Args:(float32)
-        vertices: [nver, 3]. 
-        s: [1,]. scale factor.
-        R: [3,3]. rotation matrix.
-        t3d: [3,]. 3d translation vector.
-    Returns:
-        transformed vertices: [nver, 3]
-    '''
-    t3d = np.squeeze(np.array(t3d, dtype = np.float32))
-    transformed_vertices = s * vertices.dot(R.T) + t3d[np.newaxis, :]
-
-    return transformed_vertices
-
-
-## -------------- Camera. from world space to camera space
-# Ref: https://cs184.eecs.berkeley.edu/lecture/transforms-2
-def normalize(x):
-    epsilon = 1e-12
-    norm = np.sqrt(np.sum(x**2, axis = 0))
-    norm = np.maximum(norm, epsilon)
-    return x/norm
-
-def lookat_camera(vertices, eye, at = None, up = None):
-    """ 'look at' transformation: from world space to camera space
-    standard camera space: 
-        camera located at the origin. 
-        looking down negative z-axis. 
-        vertical vector is y-axis.
-    Xcam = R(X - C)
-    Homo: [[R, -RC], [0, 1]]
-    Args:
-      vertices: [nver, 3] 
-      eye: [3,] the XYZ world space position of the camera.
-      at: [3,] a position along the center of the camera's gaze.
-      up: [3,] up direction 
-    Returns:
-      transformed_vertices: [nver, 3]
-    """
-    if at is None:
-      at = np.array([0, 0, 0], np.float32)
-    if up is None:
-      up = np.array([0, 1, 0], np.float32)
-
-    eye = np.array(eye).astype(np.float32)
-    at = np.array(at).astype(np.float32)
-    z_aixs = -normalize(at - eye) # look forward
-    x_aixs = normalize(np.cross(up, z_aixs)) # look right
-    y_axis = np.cross(z_aixs, x_aixs) # look up
-
-    R = np.stack((x_aixs, y_axis, z_aixs))#, axis = 0) # 3 x 3
-    transformed_vertices = vertices - eye # translation
-    transformed_vertices = transformed_vertices.dot(R.T) # rotation
-    return transformed_vertices
-
-## --------- 3d-2d project. from camera space to image plane
-# generally, image plane only keeps x,y channels, here reserve z channel for calculating z-buffer.
-def orthographic_project(vertices):
-    ''' scaled orthographic projection(just delete z)
-        assumes: variations in depth over the object is small relative to the mean distance from camera to object
-        x -> x*f/z, y -> x*f/z, z -> f.
-        for point i,j. zi~=zj. so just delete z
-        ** often used in face
-        Homo: P = [[1,0,0,0], [0,1,0,0], [0,0,1,0]]
-    Args:
-        vertices: [nver, 3]
-    Returns:
-        projected_vertices: [nver, 3] if isKeepZ=True. [nver, 2] if isKeepZ=False.
-    '''
-    return vertices.copy()
-
-def perspective_project(vertices, fovy, aspect_ratio = 1., near = 0.1, far = 1000.):
-    ''' perspective projection.
-    Args:
-        vertices: [nver, 3]
-        fovy: vertical angular field of view. degree.
-        aspect_ratio : width / height of field of view
-        near : depth of near clipping plane
-        far : depth of far clipping plane
-    Returns:
-        projected_vertices: [nver, 3] 
-    '''
-    fovy = np.deg2rad(fovy)
-    top = near*np.tan(fovy)
-    bottom = -top 
-    right = top*aspect_ratio
-    left = -right
-
-    #-- homo
-    P = np.array([[near/right, 0, 0, 0],
-                 [0, near/top, 0, 0],
-                 [0, 0, -(far+near)/(far-near), -2*far*near/(far-near)],
-                 [0, 0, -1, 0]])
-    vertices_homo = np.hstack((vertices, np.ones((vertices.shape[0], 1)))) # [nver, 4]
-    projected_vertices = vertices_homo.dot(P.T)
-    projected_vertices = projected_vertices/projected_vertices[:,3:]
-    projected_vertices = projected_vertices[:,:3]
-    projected_vertices[:,2] = -projected_vertices[:,2]
-
-    #-- non homo. only fovy
-    # projected_vertices = vertices.copy()
-    # projected_vertices[:,0] = -(near/right)*vertices[:,0]/vertices[:,2]
-    # projected_vertices[:,1] = -(near/top)*vertices[:,1]/vertices[:,2]
-    return projected_vertices
-
-
-def to_image(vertices, h, w, is_perspective = False):
-    ''' change vertices to image coord system
-    3d system: XYZ, center(0, 0, 0)
-    2d image: x(u), y(v). center(w/2, h/2), flip y-axis. 
-    Args:
-        vertices: [nver, 3]
-        h: height of the rendering
-        w : width of the rendering
-    Returns:
-        projected_vertices: [nver, 3]  
-    '''
-    image_vertices = vertices.copy()
-    if is_perspective:
-        # if perspective, the projected vertices are normalized to [-1, 1]. so change it to image size first.
-        image_vertices[:,0] = image_vertices[:,0]*w/2
-        image_vertices[:,1] = image_vertices[:,1]*h/2
-    # move to center of image
-    image_vertices[:,0] = image_vertices[:,0] + w/2
-    image_vertices[:,1] = image_vertices[:,1] + h/2
-    # flip vertices along y-axis.
-    image_vertices[:,1] = h - image_vertices[:,1] - 1
-    return image_vertices
-
-
-#### -------------------------------------------2. estimate transform matrix from correspondences.
-def estimate_affine_matrix_3d23d(X, Y):
-    ''' Using least-squares solution 
-    Args:
-        X: [n, 3]. 3d points(fixed)
-        Y: [n, 3]. corresponding 3d points(moving). Y = PX
-    Returns:
-        P_Affine: (3, 4). Affine camera matrix (the third row is [0, 0, 0, 1]).
-    '''
-    X_homo = np.hstack((X, np.ones([X.shape[1],1]))) #n x 4
-    P = np.linalg.lstsq(X_homo, Y)[0].T # Affine matrix. 3 x 4
-    return P
-    
-def estimate_affine_matrix_3d22d(X, x):
-    ''' Using Golden Standard Algorithm for estimating an affine camera
-        matrix P from world to image correspondences.
-        See Alg.7.2. in MVGCV 
-        Code Ref: https://github.com/patrikhuber/eos/blob/master/include/eos/fitting/affine_camera_estimation.hpp
-        x_homo = X_homo.dot(P_Affine)
-    Args:
-        X: [n, 3]. corresponding 3d points(fixed)
-        x: [n, 2]. n>=4. 2d points(moving). x = PX
-    Returns:
-        P_Affine: [3, 4]. Affine camera matrix
-    '''
-    X = X.T; x = x.T
-    assert(x.shape[1] == X.shape[1])
-    n = x.shape[1]
-    assert(n >= 4)
-
-    #--- 1. normalization
-    # 2d points
-    mean = np.mean(x, 1) # (2,)
-    x = x - np.tile(mean[:, np.newaxis], [1, n])
-    average_norm = np.mean(np.sqrt(np.sum(x**2, 0)))
-    scale = np.sqrt(2) / average_norm
-    x = scale * x
-
-    T = np.zeros((3,3), dtype = np.float32)
-    T[0, 0] = T[1, 1] = scale
-    T[:2, 2] = -mean*scale
-    T[2, 2] = 1
-
-    # 3d points
-    X_homo = np.vstack((X, np.ones((1, n))))
-    mean = np.mean(X, 1) # (3,)
-    X = X - np.tile(mean[:, np.newaxis], [1, n])
-    m = X_homo[:3,:] - X
-    average_norm = np.mean(np.sqrt(np.sum(X**2, 0)))
-    scale = np.sqrt(3) / average_norm
-    X = scale * X
-
-    U = np.zeros((4,4), dtype = np.float32)
-    U[0, 0] = U[1, 1] = U[2, 2] = scale
-    U[:3, 3] = -mean*scale
-    U[3, 3] = 1
-
-    # --- 2. equations
-    A = np.zeros((n*2, 8), dtype = np.float32);
-    X_homo = np.vstack((X, np.ones((1, n)))).T
-    A[:n, :4] = X_homo
-    A[n:, 4:] = X_homo
-    b = np.reshape(x, [-1, 1])
- 
-    # --- 3. solution
-    p_8 = np.linalg.pinv(A).dot(b)
-    P = np.zeros((3, 4), dtype = np.float32)
-    P[0, :] = p_8[:4, 0]
-    P[1, :] = p_8[4:, 0]
-    P[-1, -1] = 1
-
-    # --- 4. denormalization
-    P_Affine = np.linalg.inv(T).dot(P.dot(U))
-    return P_Affine
-
-def P2sRt(P):
-    ''' decompositing camera matrix P
-    Args: 
-        P: (3, 4). Affine Camera Matrix.
-    Returns:
-        s: scale factor.
-        R: (3, 3). rotation matrix.
-        t: (3,). translation. 
-    '''
-    t = P[:, 3]
-    R1 = P[0:1, :3]
-    R2 = P[1:2, :3]
-    s = (np.linalg.norm(R1) + np.linalg.norm(R2))/2.0
-    r1 = R1/np.linalg.norm(R1)
-    r2 = R2/np.linalg.norm(R2)
-    r3 = np.cross(r1, r2)
-
-    R = np.concatenate((r1, r2, r3), 0)
-    return s, R, t
-
-#Ref: https://www.learnopencv.com/rotation-matrix-to-euler-angles/
-def isRotationMatrix(R):
-    ''' checks if a matrix is a valid rotation matrix(whether orthogonal or not)
-    '''
-    Rt = np.transpose(R)
-    shouldBeIdentity = np.dot(Rt, R)
-    I = np.identity(3, dtype = R.dtype)
-    n = np.linalg.norm(I - shouldBeIdentity)
-    return n < 1e-6
-
-def matrix2angle(R):
-    ''' get three Euler angles from Rotation Matrix
-    Args:
-        R: (3,3). rotation matrix
-    Returns:
-        x: pitch
-        y: yaw
-        z: roll
-    '''
-    assert(isRotationMatrix)
-    sy = math.sqrt(R[0,0] * R[0,0] +  R[1,0] * R[1,0])
-     
-    singular = sy < 1e-6
- 
-    if  not singular :
-        x = math.atan2(R[2,1] , R[2,2])
-        y = math.atan2(-R[2,0], sy)
-        z = math.atan2(R[1,0], R[0,0])
-    else :
-        x = math.atan2(-R[1,2], R[1,1])
-        y = math.atan2(-R[2,0], sy)
-        z = 0
-
-    # rx, ry, rz = np.rad2deg(x), np.rad2deg(y), np.rad2deg(z)
-    rx, ry, rz = x*180/np.pi, y*180/np.pi, z*180/np.pi
-    return rx, ry, rz
-
-# def matrix2angle(R):
-#     ''' compute three Euler angles from a Rotation Matrix. Ref: http://www.gregslabaugh.net/publications/euler.pdf
-#     Args:
-#         R: (3,3). rotation matrix
-#     Returns:
-#         x: yaw
-#         y: pitch
-#         z: roll
-#     '''
-#     # assert(isRotationMatrix(R))
-
-#     if R[2,0] !=1 or R[2,0] != -1:
-#         x = math.asin(R[2,0])
-#         y = math.atan2(R[2,1]/cos(x), R[2,2]/cos(x))
-#         z = math.atan2(R[1,0]/cos(x), R[0,0]/cos(x))
-        
-#     else:# Gimbal lock
-#         z = 0 #can be anything
-#         if R[2,0] == -1:
-#             x = np.pi/2
-#             y = z + math.atan2(R[0,1], R[0,2])
-#         else:
-#             x = -np.pi/2
-#             y = -z + math.atan2(-R[0,1], -R[0,2])
-
-#     return x, y, z

insightface/thirdparty/face3d/mesh/vis.py

@@ -1,24 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import matplotlib.pyplot as plt
-from skimage import measure
-from mpl_toolkits.mplot3d import Axes3D
-
-def plot_mesh(vertices, triangles, subplot = [1,1,1], title = 'mesh', el = 90, az = -90, lwdt=.1, dist = 6, color = "grey"):
-	'''
-	plot the mesh 
-	Args:
-		vertices: [nver, 3]
-		triangles: [ntri, 3]
-	'''
-	ax = plt.subplot(subplot[0], subplot[1], subplot[2], projection = '3d')
-	ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2], triangles = triangles, lw = lwdt, color = color, alpha = 1)
-	ax.axis("off")
-	ax.view_init(elev = el, azim = az)
-	ax.dist = dist
-	plt.title(title)
-
-### -------------- Todo: use vtk to visualize mesh? or visvis? or VisPy?

insightface/thirdparty/face3d/mesh_numpy/__init__.py

@@ -1,10 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-from . import io
-from . import vis
-from . import transform
-from . import light
-from . import render
-

insightface/thirdparty/face3d/mesh_numpy/io.py

@@ -1,170 +0,0 @@
-''' io: read&write mesh
-1. read obj as array(TODO)
-2. write arrays to obj
-
-Preparation knowledge:
-representations of 3d face: mesh, point cloud...
-storage format: obj, ply, bin, asc, mat...
-'''
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import os
-from skimage import io
-
-## TODO
-## TODO: c++ version
-def read_obj(obj_name):
-	''' read mesh
-	'''
-	return 0
-
-# ------------------------- write
-def write_asc(path, vertices):
-    '''
-    Args:
-        vertices: shape = (nver, 3)
-    '''
-    if path.split('.')[-1] == 'asc':
-        np.savetxt(path, vertices)
-    else:
-        np.savetxt(path + '.asc', vertices)
-
-def write_obj_with_colors(obj_name, vertices, triangles, colors):
-    ''' Save 3D face model with texture represented by colors.
-    Args:
-        obj_name: str
-        vertices: shape = (nver, 3)
-        triangles: shape = (ntri, 3)
-        colors: shape = (nver, 3)
-    '''
-    triangles = triangles.copy()
-    triangles += 1 # meshlab start with 1
-    
-    if obj_name.split('.')[-1] != 'obj':
-        obj_name = obj_name + '.obj'
-        
-    # write obj
-    with open(obj_name, 'w') as f:
-        
-        # write vertices & colors
-        for i in range(vertices.shape[0]):
-            # s = 'v {} {} {} \n'.format(vertices[0,i], vertices[1,i], vertices[2,i])
-            s = 'v {} {} {} {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2], colors[i, 0], colors[i, 1], colors[i, 2])
-            f.write(s)
-
-        # write f: ver ind/ uv ind
-        [k, ntri] = triangles.shape
-        for i in range(triangles.shape[0]):
-            # s = 'f {} {} {}\n'.format(triangles[i, 0], triangles[i, 1], triangles[i, 2])
-            s = 'f {} {} {}\n'.format(triangles[i, 2], triangles[i, 1], triangles[i, 0])
-            f.write(s)
-
-## TODO: c++ version
-def write_obj_with_texture(obj_name, vertices, triangles, texture, uv_coords):
-    ''' Save 3D face model with texture represented by texture map.
-    Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp
-    Args:
-        obj_name: str
-        vertices: shape = (nver, 3)
-        triangles: shape = (ntri, 3)
-        texture: shape = (256,256,3)
-        uv_coords: shape = (nver, 3) max value<=1
-    '''
-    if obj_name.split('.')[-1] != 'obj':
-        obj_name = obj_name + '.obj'
-    mtl_name = obj_name.replace('.obj', '.mtl')
-    texture_name = obj_name.replace('.obj', '_texture.png')
-    
-    triangles = triangles.copy()
-    triangles += 1 # mesh lab start with 1
-    
-    # write obj
-    with open(obj_name, 'w') as f:
-        # first line: write mtlib(material library)
-        s = "mtllib {}\n".format(os.path.abspath(mtl_name))
-        f.write(s)
-
-        # write vertices
-        for i in range(vertices.shape[0]):
-            s = 'v {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2])
-            f.write(s)
-        
-        # write uv coords
-        for i in range(uv_coords.shape[0]):
-            # s = 'vt {} {}\n'.format(uv_coords[i,0], 1 - uv_coords[i,1])
-            s = 'vt {} {}\n'.format(uv_coords[i,0], uv_coords[i,1])
-            f.write(s)
-
-        f.write("usemtl FaceTexture\n")
-
-        # write f: ver ind/ uv ind
-        for i in range(triangles.shape[0]):
-            s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,2], triangles[i,2], triangles[i,1], triangles[i,1], triangles[i,0], triangles[i,0])
-            f.write(s)
-
-    # write mtl
-    with open(mtl_name, 'w') as f:
-        f.write("newmtl FaceTexture\n")
-        s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image
-        f.write(s)
-
-    # write texture as png
-    imsave(texture_name, texture)
-
-
-def write_obj_with_colors_texture(obj_name, vertices, triangles, colors, texture, uv_coords):
-    ''' Save 3D face model with texture. 
-    Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp
-    Args:
-        obj_name: str
-        vertices: shape = (nver, 3)
-        triangles: shape = (ntri, 3)
-        colors: shape = (nver, 3)
-        texture: shape = (256,256,3)
-        uv_coords: shape = (nver, 3) max value<=1
-    '''
-    if obj_name.split('.')[-1] != 'obj':
-        obj_name = obj_name + '.obj'
-    mtl_name = obj_name.replace('.obj', '.mtl')
-    texture_name = obj_name.replace('.obj', '_texture.png')
-    
-    triangles = triangles.copy()
-    triangles += 1 # mesh lab start with 1
-    
-    # write obj
-    with open(obj_name, 'w') as f:
-        # first line: write mtlib(material library)
-        s = "mtllib {}\n".format(os.path.abspath(mtl_name))
-        f.write(s)
-
-        # write vertices
-        for i in range(vertices.shape[0]):
-            s = 'v {} {} {} {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2], colors[i, 0], colors[i, 1], colors[i, 2])
-            f.write(s)
-        
-        # write uv coords
-        for i in range(uv_coords.shape[0]):
-            # s = 'vt {} {}\n'.format(uv_coords[i,0], 1 - uv_coords[i,1])
-            s = 'vt {} {}\n'.format(uv_coords[i,0], uv_coords[i,1])
-            f.write(s)
-
-        f.write("usemtl FaceTexture\n")
-
-        # write f: ver ind/ uv ind
-        for i in range(triangles.shape[0]):
-            # s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,0], triangles[i,0], triangles[i,1], triangles[i,1], triangles[i,2], triangles[i,2])
-            s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,2], triangles[i,2], triangles[i,1], triangles[i,1], triangles[i,0], triangles[i,0])
-            f.write(s)
-
-    # write mtl
-    with open(mtl_name, 'w') as f:
-        f.write("newmtl FaceTexture\n")
-        s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image
-        f.write(s)
-
-    # write texture as png
-    io.imsave(texture_name, texture)

insightface/thirdparty/face3d/mesh_numpy/light.py

@@ -1,215 +0,0 @@
-'''
-Functions about lighting mesh(changing colors/texture of mesh).
-1. add light to colors/texture (shade each vertex)
-2. fit light according to colors/texture & image.
-
-Preparation knowledge:
-lighting: https://cs184.eecs.berkeley.edu/lecture/pipeline
-spherical harmonics in human face: '3D Face Reconstruction from a Single Image Using a Single Reference Face Shape'
-'''
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-
-def get_normal(vertices, triangles):
-    ''' calculate normal direction in each vertex
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-    Returns:
-        normal: [nver, 3]
-    '''
-    pt0 = vertices[triangles[:, 0], :] # [ntri, 3]
-    pt1 = vertices[triangles[:, 1], :] # [ntri, 3]
-    pt2 = vertices[triangles[:, 2], :] # [ntri, 3]
-    tri_normal = np.cross(pt0 - pt1, pt0 - pt2) # [ntri, 3]. normal of each triangle
-
-    normal = np.zeros_like(vertices) # [nver, 3]
-    for i in range(triangles.shape[0]):
-        normal[triangles[i, 0], :] = normal[triangles[i, 0], :] + tri_normal[i, :]
-        normal[triangles[i, 1], :] = normal[triangles[i, 1], :] + tri_normal[i, :]
-        normal[triangles[i, 2], :] = normal[triangles[i, 2], :] + tri_normal[i, :]
-    
-    # normalize to unit length
-    mag = np.sum(normal**2, 1) # [nver]
-    zero_ind = (mag == 0)
-    mag[zero_ind] = 1;
-    normal[zero_ind, 0] = np.ones((np.sum(zero_ind)))
-
-    normal = normal/np.sqrt(mag[:,np.newaxis])
-
-    return normal
-
-# TODO: test
-def add_light_sh(vertices, triangles, colors, sh_coeff):
-    ''' 
-    In 3d face, usually assume:
-    1. The surface of face is Lambertian(reflect only the low frequencies of lighting)
-    2. Lighting can be an arbitrary combination of point sources
-    --> can be expressed in terms of spherical harmonics(omit the lighting coefficients)
-    I = albedo * (sh(n) x sh_coeff)
-    
-    albedo: n x 1
-    sh_coeff: 9 x 1
-    Y(n) = (1, n_x, n_y, n_z, n_xn_y, n_xn_z, n_yn_z, n_x^2 - n_y^2, 3n_z^2 - 1)': n x 9 
-    # Y(n) = (1, n_x, n_y, n_z)': n x 4
-
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-        colors: [nver, 3] albedo
-        sh_coeff: [9, 1] spherical harmonics coefficients
-
-    Returns:
-        lit_colors: [nver, 3]
-    '''
-    assert vertices.shape[0] == colors.shape[0]
-    nver = vertices.shape[0]
-    normal = get_normal(vertices, triangles) # [nver, 3]
-    sh = np.array((np.ones(nver), n[:,0], n[:,1], n[:,2], n[:,0]*n[:,1], n[:,0]*n[:,2], n[:,1]*n[:,2], n[:,0]**2 - n[:,1]**2, 3*(n[:,2]**2) - 1)) # [nver, 9]
-    ref = sh.dot(sh_coeff) #[nver, 1]
-    lit_colors = colors*ref
-    return lit_colors
-
-
-def add_light(vertices, triangles, colors, light_positions = 0, light_intensities = 0):
-    ''' Gouraud shading. add point lights.
-    In 3d face, usually assume:
-    1. The surface of face is Lambertian(reflect only the low frequencies of lighting)
-    2. Lighting can be an arbitrary combination of point sources
-    3. No specular (unless skin is oil, 23333)
-
-    Ref: https://cs184.eecs.berkeley.edu/lecture/pipeline    
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-        light_positions: [nlight, 3] 
-        light_intensities: [nlight, 3]
-    Returns:
-        lit_colors: [nver, 3]
-    '''
-    nver = vertices.shape[0]
-    normals = get_normal(vertices, triangles) # [nver, 3]
-
-    # ambient
-    # La = ka*Ia
-
-    # diffuse
-    # Ld = kd*(I/r^2)max(0, nxl)
-    direction_to_lights = vertices[np.newaxis, :, :] - light_positions[:, np.newaxis, :] # [nlight, nver, 3]
-    direction_to_lights_n = np.sqrt(np.sum(direction_to_lights**2, axis = 2)) # [nlight, nver]
-    direction_to_lights = direction_to_lights/direction_to_lights_n[:, :, np.newaxis]
-    normals_dot_lights = normals[np.newaxis, :, :]*direction_to_lights # [nlight, nver, 3]
-    normals_dot_lights = np.sum(normals_dot_lights, axis = 2) # [nlight, nver]
-    diffuse_output = colors[np.newaxis, :, :]*normals_dot_lights[:, :, np.newaxis]*light_intensities[:, np.newaxis, :]
-    diffuse_output = np.sum(diffuse_output, axis = 0) # [nver, 3]
-    
-    # specular
-    # h = (v + l)/(|v + l|) bisector
-    # Ls = ks*(I/r^2)max(0, nxh)^p
-    # increasing p narrows the reflectionlob
-
-    lit_colors = diffuse_output # only diffuse part here.
-    lit_colors = np.minimum(np.maximum(lit_colors, 0), 1)
-    return lit_colors
-
-
-
-## TODO. estimate light(sh coeff)
-## -------------------------------- estimate. can not use now. 
-def fit_light(image, vertices, colors, triangles, vis_ind, lamb = 10, max_iter = 3):
-    [h, w, c] = image.shape
-
-    # surface normal
-    norm = get_normal(vertices, triangles)
-    
-    nver = vertices.shape[1]
-
-    # vertices --> corresponding image pixel
-    pt2d = vertices[:2, :]
-
-    pt2d[0,:] = np.minimum(np.maximum(pt2d[0,:], 0), w - 1)
-    pt2d[1,:] = np.minimum(np.maximum(pt2d[1,:], 0), h - 1)
-    pt2d = np.round(pt2d).astype(np.int32) # 2 x nver
-
-    image_pixel = image[pt2d[1,:], pt2d[0,:], :] # nver x 3
-    image_pixel = image_pixel.T # 3 x nver
-
-    # vertices --> corresponding mean texture pixel with illumination
-    # Spherical Harmonic Basis
-    harmonic_dim = 9
-    nx = norm[0,:];
-    ny = norm[1,:];
-    nz = norm[2,:];
-    harmonic = np.zeros((nver, harmonic_dim))
-
-    pi = np.pi
-    harmonic[:,0] = np.sqrt(1/(4*pi)) * np.ones((nver,));
-    harmonic[:,1] = np.sqrt(3/(4*pi)) * nx;
-    harmonic[:,2] = np.sqrt(3/(4*pi)) * ny;
-    harmonic[:,3] = np.sqrt(3/(4*pi)) * nz;
-    harmonic[:,4] = 1/2. * np.sqrt(3/(4*pi)) * (2*nz**2 - nx**2 - ny**2);
-    harmonic[:,5] = 3 * np.sqrt(5/(12*pi)) * (ny*nz);
-    harmonic[:,6] = 3 * np.sqrt(5/(12*pi)) * (nx*nz);
-    harmonic[:,7] = 3 * np.sqrt(5/(12*pi)) * (nx*ny);
-    harmonic[:,8] = 3/2. * np.sqrt(5/(12*pi)) * (nx*nx - ny*ny);
-    
-    '''
-    I' = sum(albedo * lj * hj) j = 0:9 (albedo = tex)
-    set A = albedo*h (n x 9)
-        alpha = lj (9 x 1)
-        Y = I (n x 1)
-        Y' = A.dot(alpha)
-
-    opt function:
-        ||Y - A*alpha|| + lambda*(alpha'*alpha)
-    result:
-        A'*(Y - A*alpha) + lambda*alpha = 0
-        ==>
-        (A'*A*alpha - lambda)*alpha = A'*Y
-        left: 9 x 9
-        right: 9 x 1
-    '''
-    n_vis_ind = len(vis_ind)
-    n = n_vis_ind*c
-
-    Y = np.zeros((n, 1))
-    A = np.zeros((n, 9))
-    light = np.zeros((3, 1))
-
-    for k in range(c):
-        Y[k*n_vis_ind:(k+1)*n_vis_ind, :] = image_pixel[k, vis_ind][:, np.newaxis]
-        A[k*n_vis_ind:(k+1)*n_vis_ind, :] = texture[k, vis_ind][:, np.newaxis] * harmonic[vis_ind, :]
-        Ac = texture[k, vis_ind][:, np.newaxis]
-        Yc = image_pixel[k, vis_ind][:, np.newaxis]
-        light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac))
-
-    for i in range(max_iter):
-
-        Yc = Y.copy()
-        for k in range(c):
-            Yc[k*n_vis_ind:(k+1)*n_vis_ind, :]  /= light[k]
-
-        # update alpha
-        equation_left = np.dot(A.T, A) + lamb*np.eye(harmonic_dim); # why + ?
-        equation_right = np.dot(A.T, Yc) 
-        alpha = np.dot(np.linalg.inv(equation_left), equation_right)
-
-        # update light
-        for k in range(c):
-            Ac = A[k*n_vis_ind:(k+1)*n_vis_ind, :].dot(alpha)
-            Yc = Y[k*n_vis_ind:(k+1)*n_vis_ind, :]
-            light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac))
-
-    appearance = np.zeros_like(texture)
-    for k in range(c):
-        tmp = np.dot(harmonic*texture[k, :][:, np.newaxis], alpha*light[k])
-        appearance[k,:] = tmp.T
-
-    appearance = np.minimum(np.maximum(appearance, 0), 1)
-
-    return appearance
-

insightface/thirdparty/face3d/mesh_numpy/render.py

@@ -1,287 +0,0 @@
-'''
-functions about rendering mesh(from 3d obj to 2d image).
-only use rasterization render here.
-Note that:
-1. Generally, render func includes camera, light, raterize. Here no camera and light(I write these in other files)
-2. Generally, the input vertices are normalized to [-1,1] and cetered on [0, 0]. (in world space)
-   Here, the vertices are using image coords, which centers on [w/2, h/2] with the y-axis pointing to oppisite direction.
-Means: render here only conducts interpolation.(I just want to make the input flexible)
-
-Preparation knowledge:
-z-buffer: https://cs184.eecs.berkeley.edu/lecture/pipeline
-
-Author: Yao Feng 
-Mail: yaofeng1995@gmail.com
-'''
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-from time import time
-
-def isPointInTri(point, tri_points):
-    ''' Judge whether the point is in the triangle
-    Method:
-        http://blackpawn.com/texts/pointinpoly/
-    Args:
-        point: (2,). [u, v] or [x, y] 
-        tri_points: (3 vertices, 2 coords). three vertices(2d points) of a triangle. 
-    Returns:
-        bool: true for in triangle
-    '''
-    tp = tri_points
-
-    # vectors
-    v0 = tp[2,:] - tp[0,:]
-    v1 = tp[1,:] - tp[0,:]
-    v2 = point - tp[0,:]
-
-    # dot products
-    dot00 = np.dot(v0.T, v0)
-    dot01 = np.dot(v0.T, v1)
-    dot02 = np.dot(v0.T, v2)
-    dot11 = np.dot(v1.T, v1)
-    dot12 = np.dot(v1.T, v2)
-
-    # barycentric coordinates
-    if dot00*dot11 - dot01*dot01 == 0:
-        inverDeno = 0
-    else:
-        inverDeno = 1/(dot00*dot11 - dot01*dot01)
-
-    u = (dot11*dot02 - dot01*dot12)*inverDeno
-    v = (dot00*dot12 - dot01*dot02)*inverDeno
-
-    # check if point in triangle
-    return (u >= 0) & (v >= 0) & (u + v < 1)
-
-def get_point_weight(point, tri_points):
-    ''' Get the weights of the position
-    Methods: https://gamedev.stackexchange.com/questions/23743/whats-the-most-efficient-way-to-find-barycentric-coordinates
-     -m1.compute the area of the triangles formed by embedding the point P inside the triangle
-     -m2.Christer Ericson's book "Real-Time Collision Detection". faster.(used)
-    Args:
-        point: (2,). [u, v] or [x, y] 
-        tri_points: (3 vertices, 2 coords). three vertices(2d points) of a triangle. 
-    Returns:
-        w0: weight of v0
-        w1: weight of v1
-        w2: weight of v3
-     '''
-    tp = tri_points
-    # vectors
-    v0 = tp[2,:] - tp[0,:]
-    v1 = tp[1,:] - tp[0,:]
-    v2 = point - tp[0,:]
-
-    # dot products
-    dot00 = np.dot(v0.T, v0)
-    dot01 = np.dot(v0.T, v1)
-    dot02 = np.dot(v0.T, v2)
-    dot11 = np.dot(v1.T, v1)
-    dot12 = np.dot(v1.T, v2)
-
-    # barycentric coordinates
-    if dot00*dot11 - dot01*dot01 == 0:
-        inverDeno = 0
-    else:
-        inverDeno = 1/(dot00*dot11 - dot01*dot01)
-
-    u = (dot11*dot02 - dot01*dot12)*inverDeno
-    v = (dot00*dot12 - dot01*dot02)*inverDeno
-
-    w0 = 1 - u - v
-    w1 = v
-    w2 = u
-
-    return w0, w1, w2
-
-def rasterize_triangles(vertices, triangles, h, w):
-    ''' 
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3]
-        h: height
-        w: width
-    Returns:
-        depth_buffer: [h, w] saves the depth, here, the bigger the z, the fronter the point.
-        triangle_buffer: [h, w] saves the tri id(-1 for no triangle). 
-        barycentric_weight: [h, w, 3] saves corresponding barycentric weight.
-
-    # Each triangle has 3 vertices & Each vertex has 3 coordinates x, y, z.
-    # h, w is the size of rendering
-    '''
-    # initial 
-    depth_buffer = np.zeros([h, w]) - 999999. #+ np.min(vertices[2,:]) - 999999. # set the initial z to the farest position
-    triangle_buffer = np.zeros([h, w], dtype = np.int32) - 1  # if tri id = -1, the pixel has no triangle correspondance
-    barycentric_weight = np.zeros([h, w, 3], dtype = np.float32)  # 
-    
-    for i in range(triangles.shape[0]):
-        tri = triangles[i, :] # 3 vertex indices
-
-        # the inner bounding box
-        umin = max(int(np.ceil(np.min(vertices[tri, 0]))), 0)
-        umax = min(int(np.floor(np.max(vertices[tri, 0]))), w-1)
-
-        vmin = max(int(np.ceil(np.min(vertices[tri, 1]))), 0)
-        vmax = min(int(np.floor(np.max(vertices[tri, 1]))), h-1)
-
-        if umax<umin or vmax<vmin:
-            continue
-
-        for u in range(umin, umax+1):
-            for v in range(vmin, vmax+1):
-                if not isPointInTri([u,v], vertices[tri, :2]): 
-                    continue
-                w0, w1, w2 = get_point_weight([u, v], vertices[tri, :2]) # barycentric weight
-                point_depth = w0*vertices[tri[0], 2] + w1*vertices[tri[1], 2] + w2*vertices[tri[2], 2]
-                if point_depth > depth_buffer[v, u]:
-                    depth_buffer[v, u] = point_depth
-                    triangle_buffer[v, u] = i
-                    barycentric_weight[v, u, :] = np.array([w0, w1, w2])
-
-    return depth_buffer, triangle_buffer, barycentric_weight
-
-
-def render_colors_ras(vertices, triangles, colors, h, w, c = 3):
-    ''' render mesh with colors(rasterize triangle first)
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3] 
-        colors: [nver, 3]
-        h: height
-        w: width    
-        c: channel
-    Returns:
-        image: [h, w, c]. rendering.
-    '''
-    assert vertices.shape[0] == colors.shape[0]
-
-    depth_buffer, triangle_buffer, barycentric_weight = rasterize_triangles(vertices, triangles, h, w)
-
-    triangle_buffer_flat = np.reshape(triangle_buffer, [-1]) # [h*w]
-    barycentric_weight_flat = np.reshape(barycentric_weight, [-1, c]) #[h*w, c]
-    weight = barycentric_weight_flat[:, :, np.newaxis] # [h*w, 3(ver in tri), 1]
-
-    colors_flat = colors[triangles[triangle_buffer_flat, :], :] # [h*w(tri id in pixel), 3(ver in tri), c(color in ver)]
-    colors_flat = weight*colors_flat # [h*w, 3, 3]
-    colors_flat = np.sum(colors_flat, 1) #[h*w, 3]. add tri.
-
-    image = np.reshape(colors_flat, [h, w, c])
-    # mask = (triangle_buffer[:,:] > -1).astype(np.float32)
-    # image = image*mask[:,:,np.newaxis]
-    return image
-
-
-def render_colors(vertices, triangles, colors, h, w, c = 3):
-    ''' render mesh with colors
-    Args:
-        vertices: [nver, 3]
-        triangles: [ntri, 3] 
-        colors: [nver, 3]
-        h: height
-        w: width    
-    Returns:
-        image: [h, w, c]. 
-    '''
-    assert vertices.shape[0] == colors.shape[0]
-    
-    # initial 
-    image = np.zeros((h, w, c))
-    depth_buffer = np.zeros([h, w]) - 999999.
-
-    for i in range(triangles.shape[0]):
-        tri = triangles[i, :] # 3 vertex indices
-
-        # the inner bounding box
-        umin = max(int(np.ceil(np.min(vertices[tri, 0]))), 0)
-        umax = min(int(np.floor(np.max(vertices[tri, 0]))), w-1)
-
-        vmin = max(int(np.ceil(np.min(vertices[tri, 1]))), 0)
-        vmax = min(int(np.floor(np.max(vertices[tri, 1]))), h-1)
-
-        if umax<umin or vmax<vmin:
-            continue
-
-        for u in range(umin, umax+1):
-            for v in range(vmin, vmax+1):
-                if not isPointInTri([u,v], vertices[tri, :2]): 
-                    continue
-                w0, w1, w2 = get_point_weight([u, v], vertices[tri, :2])
-                point_depth = w0*vertices[tri[0], 2] + w1*vertices[tri[1], 2] + w2*vertices[tri[2], 2]
-
-                if point_depth > depth_buffer[v, u]:
-                    depth_buffer[v, u] = point_depth
-                    image[v, u, :] = w0*colors[tri[0], :] + w1*colors[tri[1], :] + w2*colors[tri[2], :]
-    return image
-
-
-def render_texture(vertices, triangles, texture, tex_coords, tex_triangles, h, w, c = 3, mapping_type = 'nearest'):
-    ''' render mesh with texture map
-    Args:
-        vertices: [nver], 3
-        triangles: [ntri, 3]
-        texture: [tex_h, tex_w, 3]
-        tex_coords: [ntexcoords, 3]
-        tex_triangles: [ntri, 3]
-        h: height of rendering
-        w: width of rendering
-        c: channel
-        mapping_type: 'bilinear' or 'nearest'
-    '''
-    assert triangles.shape[0] == tex_triangles.shape[0]
-    tex_h, tex_w, _ = texture.shape
-
-    # initial 
-    image = np.zeros((h, w, c))
-    depth_buffer = np.zeros([h, w]) - 999999.
-
-    for i in range(triangles.shape[0]):
-        tri = triangles[i, :] # 3 vertex indices
-        tex_tri = tex_triangles[i, :] # 3 tex indice
-
-        # the inner bounding box
-        umin = max(int(np.ceil(np.min(vertices[tri, 0]))), 0)
-        umax = min(int(np.floor(np.max(vertices[tri, 0]))), w-1)
-
-        vmin = max(int(np.ceil(np.min(vertices[tri, 1]))), 0)
-        vmax = min(int(np.floor(np.max(vertices[tri, 1]))), h-1)
-
-        if umax<umin or vmax<vmin:
-            continue
-
-        for u in range(umin, umax+1):
-            for v in range(vmin, vmax+1):
-                if not isPointInTri([u,v], vertices[tri, :2]): 
-                    continue
-                w0, w1, w2 = get_point_weight([u, v], vertices[tri, :2])
-                point_depth = w0*vertices[tri[0], 2] + w1*vertices[tri[1], 2] + w2*vertices[tri[2], 2]
-                if point_depth > depth_buffer[v, u]:
-                    # update depth
-                    depth_buffer[v, u] = point_depth    
-                    
-                    # tex coord
-                    tex_xy = w0*tex_coords[tex_tri[0], :] + w1*tex_coords[tex_tri[1], :] + w2*tex_coords[tex_tri[2], :]
-                    tex_xy[0] = max(min(tex_xy[0], float(tex_w - 1)), 0.0); 
-                    tex_xy[1] = max(min(tex_xy[1], float(tex_h - 1)), 0.0); 
-
-                    # nearest
-                    if mapping_type == 'nearest':
-                        tex_xy = np.round(tex_xy).astype(np.int32)
-                        tex_value = texture[tex_xy[1], tex_xy[0], :] 
-
-                    # bilinear
-                    elif mapping_type == 'bilinear':
-                        # next 4 pixels
-                        ul = texture[int(np.floor(tex_xy[1])), int(np.floor(tex_xy[0])), :]
-                        ur = texture[int(np.floor(tex_xy[1])), int(np.ceil(tex_xy[0])), :]
-                        dl = texture[int(np.ceil(tex_xy[1])), int(np.floor(tex_xy[0])), :]
-                        dr = texture[int(np.ceil(tex_xy[1])), int(np.ceil(tex_xy[0])), :]
-
-                        yd = tex_xy[1] - np.floor(tex_xy[1])
-                        xd = tex_xy[0] - np.floor(tex_xy[0])
-                        tex_value = ul*(1-xd)*(1-yd) + ur*xd*(1-yd) + dl*(1-xd)*yd + dr*xd*yd
-
-                    image[v, u, :] = tex_value
-    return image