cvpr_2023/data/convert_to_uv.py

import os
import sys
import glob
import tqdm
import math
import time
import random
import shutil
import collections
import argparse
import pickle
import numpy as np
import scipy as sp
import trimesh as tm
import cmapy as cm
import tables as tb
import scipy.io as sio
import scipy.interpolate as spi
import matplotlib.pyplot as plt
import scipy.stats as stat
import cv2
import plotly.express as ex
import plotly.graph_objects as go

sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
from data.cloth3d_io import read_garment_mask, read_garment_template, read_posed_garment_frame, loadInfo, read_posed_body_frame, read_posed_body, read_posed_garment, read_curvatures
from data.utils import save_to_h5file


os.environ["CUDA_VISIBLE_DEVICES"] = "6"

def convert_to_uv(res, m2uv, uv_map, verts, neighbours=10, mask=None, method='rbf', garment_uv_mask=None):
    verts_uv = np.zeros((res * 2, res, 3))
    uv_values = np.zeros((uv_map.shape[0], 3))
    uv_values[m2uv[:, 0]] = verts
    uv_values[m2uv[:, 1]] += verts
    uv_values = uv_values[uv_map_mask, :] #   add garment mask
    uv_values /= uv_counter[:, np.newaxis]
    return_garment_uv_mask = False

    if mask is not None:
        garment_mask = np.zeros((uv_map.shape[0]), dtype=bool)
        garment_mask[m2uv[:, 0]] = mask
        garment_mask[m2uv[:, 1]] += mask
        garment_mask = garment_mask[uv_map_mask] #   add garment mask
    else:
        garment_mask = np.sum(uv_values, axis=-1) != 0

    # test
    verts_uv[uv_map_discreet_unique[:, 0], uv_map_discreet_unique[:, 1], :] = uv_values
    # verts_uv_save = verts_uv.copy()

    # garment_mask = np.sum(uv_values, axis=-1) != 0
    unique_uv_values = uv_values[garment_mask, :]
    uv_map_discreet_unique_unique = uv_map_discreet_unique[garment_mask, :]
    rbf_dest_current = rbf_dest

    if garment_uv_mask is None and mask is not None:
        garment_uv_mask = np.zeros((res * 2, res))
        garment_uv_mask[uv_map_discreet_unique_unique[:, 0], uv_map_discreet_unique_unique[:, 1]] = 255
        garment_uv_mask = cv2.morphologyEx(garment_uv_mask, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_RECT, (4 * 2 + 1, 4 * 2 + 1), (4, 4)), iterations=4)
        garment_uv_mask_border = garment_uv_mask.astype(bool)
        garment_uv_mask = cv2.dilate(garment_uv_mask, cv2.getStructuringElement(cv2.MORPH_RECT, (2 * 2 + 1, 2 * 2 + 1), (2, 2)), iterations=2).astype(bool)
        garment_uv_mask_border = ~garment_uv_mask_border & garment_uv_mask
        garment_uv_mask = garment_uv_mask * uv_mask[:,:,0]
        rbf_dest_current = rbf_dest * garment_uv_mask
        return_garment_uv_mask = True


    rbf_dest_current = np.nonzero(rbf_dest_current)
    rbf_dest_current = np.array(rbf_dest_current).T

    # uv_verts_uniq = np.array(np.nonzero(np.sum(verts_uv, axis=-1))).T
    if method == 'rbf':
        interpolator =  spi.RBFInterpolator(y=uv_map_discreet_unique_unique, d=unique_uv_values, neighbors=neighbours, kernel='linear')
    elif method == 'nearest':
        interpolator =  spi.NearestNDInterpolator(x=uv_map_discreet_unique_unique, y=unique_uv_values)
    else:
        raise NotImplementedError

    final = interpolator(rbf_dest_current)

    result = np.zeros((res * 2, res, 3))

    # not sure, shouldn't be needed
    # rbf_dest[:, [0,1]] = rbf_dest[:, [1, 0]]

    result[rbf_dest_current[:, 0], rbf_dest_current[:, 1], :] = final
    result[uv_map_discreet_unique[:, 0], uv_map_discreet_unique[:, 1], :] = uv_values
    if garment_uv_mask is not None:
        result = result * garment_uv_mask[:,:,np.newaxis]

    if return_garment_uv_mask:
        return result, garment_uv_mask, garment_uv_mask_border
    else:
        return result 


def convert_to_uv_batch_body(res, m2uv, uv_map, verts, neighbours=15, mask=None, method='rbf', garment_uv_mask=None, garment_uv_mask_border=None):
    batch = verts.shape[0]
    verts_uv = np.zeros((batch, res * 2, res, 3))
    uv_values = np.zeros((batch, uv_map.shape[0], 3))
    uv_values[:, m2uv[:, 0]] = verts
    uv_values[:, m2uv[:, 1]] += verts
    uv_values = uv_values[:, uv_map_mask, :]
    uv_values /= uv_counter[np.newaxis, :, np.newaxis]
    return_garment_uv_mask = False
    # test
    verts_uv[:, uv_map_discreet_unique[:, 0], uv_map_discreet_unique[:, 1], :] = uv_values

    if mask is not None:
        garment_mask = np.zeros((uv_map.shape[0]), dtype=bool)
        garment_mask[m2uv[:, 0]] = mask
        garment_mask[m2uv[:, 1]] += mask
        garment_mask = garment_mask[uv_map_mask] #   add garment mask
    else:
        garment_mask = np.sum(uv_values[0,:,:], axis=-1) != 0

    unique_uv_values = uv_values[:, garment_mask, :]
    uv_map_discreet_unique_unique = uv_map_discreet_unique[garment_mask, :]
    rbf_dest_current = rbf_dest

    # add back mesh vertices that are not part of the garment
    uv_map_discreet_unique_unique_inv = uv_map_discreet_unique[np.invert(garment_mask), :]
    rbf_dest_fill = np.zeros((res * 2, res), dtype=bool)
    rbf_dest_fill[uv_map_discreet_unique_unique_inv[:, 0], uv_map_discreet_unique_unique_inv[:, 1]] = True
    
    if garment_uv_mask is None and mask is not None:
        garment_uv_mask = np.zeros((res * 2, res))
        garment_uv_mask[uv_map_discreet_unique_unique[:, 0], uv_map_discreet_unique_unique[:, 1]] = 255
        garment_uv_mask = cv2.morphologyEx(garment_uv_mask, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_RECT, (2 * 2 + 1, 2 * 2 + 1), (2, 2)), iterations=4)
        garment_uv_mask = cv2.dilate(garment_uv_mask, cv2.getStructuringElement(cv2.MORPH_RECT, (2 * 2 + 1, 2 * 2 + 1), (2, 2)), iterations=2).astype(bool)
        return_garment_uv_mask = True

    if garment_uv_mask is not None:
        rbf_dest_current = (rbf_dest + rbf_dest_fill) * garment_uv_mask + garment_uv_mask_border

    rbf_dest_current = np.nonzero(rbf_dest_current)
    rbf_dest_current = np.array(rbf_dest_current).T

    final = []
    for i in range(batch):
        print('processing frame: ' + str(i))
        if method == 'rbf':
            interpolator =  spi.RBFInterpolator(y=uv_map_discreet_unique_unique, d=unique_uv_values[i,:,:], neighbors=neighbours, kernel='linear')
        elif method == 'nearest':
            interpolator =  spi.NearestNDInterpolator(x=uv_map_discreet_unique_unique, y=unique_uv_values[i,:,:])
        else:
            raise NotImplementedError

        result = np.zeros((res * 2, res, 3), np.float32)
        result[rbf_dest_current[:, 0], rbf_dest_current[:, 1], :] = interpolator(rbf_dest_current)
        result[uv_map_discreet_unique_unique[:, 0], uv_map_discreet_unique_unique[:, 1], :] = unique_uv_values[i,:,:]

        if garment_uv_mask is not None:
            result *= garment_uv_mask[:,:,np.newaxis]
        
        final.append(result)

    if return_garment_uv_mask:
        return final, garment_uv_mask
    else:
        return final 
    

def convert_to_uv_batch(res, m2uv, uv_map, verts, neighbours=15, mask=None, method='rbf', garment_uv_mask=None, garment_uv_mask_border=None, id=None):
    batch = len(verts)

    assert method == 'rbf'

    assert mask is not None
    garment_mask = np.zeros((uv_map.shape[0]), dtype=bool)
    garment_mask[m2uv[:, 0]] = mask
    garment_mask[m2uv[:, 1]] += mask
    garment_mask = garment_mask[uv_map_mask] #   add garment mask

    rbf_dest_current = rbf_dest

    # add back mesh vertices that are not part of the garment
    uv_map_discreet_unique_unique_inv = uv_map_discreet_unique[np.invert(garment_mask), :]
    rbf_dest_fill = np.zeros((res * 2, res), dtype=bool)
    rbf_dest_fill[uv_map_discreet_unique_unique_inv[:, 0], uv_map_discreet_unique_unique_inv[:, 1]] = True

    assert not (garment_uv_mask is None and mask is not None)
    assert garment_uv_mask is not None
    rbf_dest_current = (rbf_dest + rbf_dest_fill) * garment_uv_mask + garment_uv_mask_border

    rbf_dest_current = np.nonzero(rbf_dest_current)
    rbf_dest_current = np.array(rbf_dest_current).T

    out = []

    for i in range(batch):
        print('processing frame: ' + str(i))

        uv_values = np.zeros((uv_map.shape[0], 3))
        uv_values[m2uv[:, 0]] = verts[i]
        uv_values[m2uv[:, 1]] += verts[i]
        uv_values = uv_values[uv_map_mask, :]
        uv_values /= uv_counter[:, np.newaxis]

        unique_uv_values = uv_values[garment_mask, :]
        uv_map_discreet_unique_unique = uv_map_discreet_unique[garment_mask, :]

        interpolator =  spi.RBFInterpolator(y=uv_map_discreet_unique_unique, d=unique_uv_values[:,:], neighbors=neighbours, kernel='linear')
        result = np.zeros((res * 2, res, 3), np.float32)
        result[rbf_dest_current[:, 0], rbf_dest_current[:, 1], :] = interpolator(rbf_dest_current)
        result[uv_map_discreet_unique_unique[:, 0], uv_map_discreet_unique_unique[:, 1], :] = unique_uv_values[:,:]

        if garment_uv_mask is not None:
            result *= garment_uv_mask[:,:,np.newaxis]
        
        out.append(result)
    
    return out


def convert_to_uv_batch_label(res, m2uv, uv_map, values, neighbours=15, mask=None, method='rbf', garment_uv_mask=None, garment_uv_mask_border=None):
    batch = values.shape[0]
    values = (values + 1) * mask
    values_uv = np.zeros((batch, res * 2, res))
    missing = np.zeros((res * 2, res))
    uv_values = np.zeros((batch, uv_map.shape[0]))
    uv_values[:, m2uv[:, 0]] = values
    uv_values[:, m2uv[:, 1]] = values
    uv_values = uv_values[:, uv_map_mask]
    return_garment_uv_mask = False

    if mask is not None:
        garment_mask = np.zeros((uv_map.shape[0]), dtype=bool)
        garment_mask[m2uv[:, 0]] = mask
        garment_mask[m2uv[:, 1]] += mask
        garment_mask = garment_mask[uv_map_mask] #   add garment mask
    else:
        raise Exception


    # test 
    values_uv[:, uv_map_discreet_unique[:, 0], uv_map_discreet_unique[:, 1]] = uv_values
    missing[uv_map_discreet_unique[:, 0], uv_map_discreet_unique[:, 1]] = (uv_values[0,:] == 0)
    
    unique_uv_values = uv_values[:, garment_mask]
    uv_map_discreet_unique_unique = uv_map_discreet_unique[garment_mask, :]
    # rbf_dest_current = rbf_dest.astype(bool) + garment_uv_mask_border * uv_mask[:,:,0]

    if garment_uv_mask is None and mask is not None:
        garment_uv_mask = np.zeros((res * 2, res))
        garment_uv_mask[uv_map_discreet_unique_unique[:, 0], uv_map_discreet_unique_unique[:, 1]] = 255
        garment_uv_mask = cv2.morphologyEx(garment_uv_mask, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_RECT, (2 * 2 + 1, 2 * 2 + 1), (2, 2)), iterations=4)
        garment_uv_mask = cv2.dilate(garment_uv_mask, cv2.getStructuringElement(cv2.MORPH_RECT, (2 * 2 + 1, 2 * 2 + 1), (2, 2)), iterations=2).astype(bool)
        return_garment_uv_mask = True

    rbf_dest_current = rbf_dest * garment_uv_mask + missing * garment_uv_mask
    rbf_dest_current = np.nonzero(rbf_dest_current)
    rbf_dest_current = np.array(rbf_dest_current).T

    # uv_verts_uniq = np.array(np.nonzero(np.sum(verts_uv, axis=-1))).T
    final = []
    for i in range(batch):
        print('processing frame: ' + str(i))
        interpolator =  spi.NearestNDInterpolator(x=uv_map_discreet_unique_unique, y=unique_uv_values[i,:])
        final.append(interpolator(rbf_dest_current))
    final = np.asarray(final)

    result = np.zeros((batch, res * 2, res))
    result[:, uv_map_discreet_unique[:, 0], uv_map_discreet_unique[:, 1]] = uv_values
    result[:, rbf_dest_current[:, 0], rbf_dest_current[:, 1]] = final
    if garment_uv_mask is not None:
        result = result * garment_uv_mask[np.newaxis,:,:]

    if return_garment_uv_mask:
        return result, garment_uv_mask
    else:
        return result 


def m2uv_array(m2uv):
    result = np.zeros((14475, 2), dtype=np.int32)
    for k, v in m2uv.items():
        if len(v) == 2:
            result[k] = list(v)
        elif len(v) == 1:
            x = v.pop()
            result[k] = [x, x]
        else:
            assert False

    return result


def uv_to_mesh(uv, m2uv):
    res = uv.shape[0]
    mesh = np.zeros((14475, 3))
    uv_pixels = uv_map_discreet[m2uv]
    # counter = np.ones((14475))
    # counter[m2uv[:, 0] == m2uv[:, 1]] = 2
    mesh = np.mean(uv[uv_pixels[:, :, 0], uv_pixels[:, :, 1], :], axis=1) # / counter[:, np.newaxis]
    return mesh
    pass


def verify_reconstruction(orig, reconstructed):
    error = np.sqrt(np.sum((orig - reconstructed) ** 2, axis=-1))
    colors = np.array([cm.color('jet', 1 - i) for i in error])
    error_sum = np.sum(error)


    verts_uv = np.zeros((uv_res * 2, uv_res, 3))
    uv_values = np.zeros((uv_map.shape[0], 3))
    uv_values[m2uv[:, 0]] = colors
    uv_values[m2uv[:, 1]] += colors
    uv_counter = np.zeros((uv_map.shape[0]))
    uv_counter[m2uv[:, 0]] = 1
    uv_counter[m2uv[:, 1]] += 1
    uv_values /= uv_counter[:, np.newaxis]
    verts_uv[uv_map_discreet[:, 0], uv_map_discreet[:, 1], :] = uv_values
    fig = plt.figure(figsize=(15, 15))
    ax = fig.add_subplot(111)
    ax.scatter(uv_map[:, 0], uv_map[:, 1], s=5, c=uv_values/255)
    plt.show()



    fig = plt.figure(figsize=(15, 15))
    ax = fig.add_subplot(121, projection='3d')
    x = orig
    ax.set_xlim3d(-1, 1)
    ax.set_ylim3d(-1, 1)
    ax.set_zlim3d(-1, 1)
    ax.set_xlabel("X")
    ax.set_ylabel("Y")
    ax.set_zlabel("Z")
    ax.scatter(x[:, 0], x[:, 1], x[:, 2], s=5)

    ax = fig.add_subplot(122, projection='3d')
    x = reconstructed#[error > 0.1, :]
    ax.set_xlim3d(-1, 1)
    ax.set_ylim3d(-1, 1)
    ax.set_zlim3d(-1, 1)
    ax.set_xlabel("X")
    ax.set_ylabel("Y")
    ax.set_zlabel("Z")
    ax.scatter(x[:, 0], x[:, 1], x[:, 2], s=5, c=colors/255) #[error > 0.1, :]

    plt.show()

    pass

# https://stackoverflow.com/questions/38187286/find-unique-pairs-in-list-of-pairs
def unique_pairs(a):
    a.sort(axis=1)
    b = np.ascontiguousarray(a).view(
        np.dtype((np.void, a.dtype.itemsize * a.shape[1]))
    )
    _, inv, ct = np.unique(b, return_inverse=True, return_counts=True)
    return ct[inv] == 1


def unique_uv_map_mask(uv_map_discreet):
    mask = np.zeros((uv_map_discreet.shape[0]), dtype=bool)
    temp = np.zeros((uv_res * 2, uv_res))
    for p in uv_map_discreet:
        temp[p[0], p[1]] += 1
    # temp = temp == 1
    for i, p in enumerate(uv_map_discreet):
        if temp[p[0], p[1]] == 1:
            mask[i] = True
        elif temp[p[0], p[1]] == 2:
            mask[i] = True
            temp[p[0], p[1]] = 0
    return mask


def test(verts, faces, values):
    uv_values = np.zeros((uv_map.shape[0], 3))
    uv_values[m2uv[:, 0]] = values
    uv_values[m2uv[:, 1]] += values
    uv_counter = np.zeros((uv_map.shape[0]))
    uv_counter[m2uv[:, 0]] = 1
    uv_counter[m2uv[:, 1]] += 1
    uv_values /= uv_counter[:, np.newaxis]
    x = uv_values
    verts = np.concatenate((verts, np.zeros((15068, 1))), axis=-1)
    im = ((x - x.min()) / (x.max() - x.min())) * 255
    tm.Trimesh(verts, faces, vertex_colors=im.astype(np.int32)).show()


def get_shapedirs():
    to_keep = sio.loadmat(os.path.join('custom_utils/keep_remove.mat'))['keep'].reshape(-1)
    shapedirs = []
    with open(os.path.join('custom_utils/super_model_f.pkl'), 'rb') as f:
        female = pickle.load(f, encoding="latin1")
        shapedirs.append(female['shapedirs'][to_keep, :])
    with open(os.path.join('custom_utils/super_model_m.pkl'), 'rb') as f:
        male = pickle.load(f, encoding="latin1")
        shapedirs.append(male['shapedirs'][to_keep, :])
    return shapedirs


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("-f", "--folder", help = "end of range", default='/home/workspace/data/dataset/cloth3d/train')
    parser.add_argument("-s", "--start", help = "start of range", default=70500)
    parser.add_argument("-e", "--end", help = "end of range", default=90000)
    parser.add_argument("-n", "--name", help = "end of range", default='lhunor')
    parser.add_argument("-sk", "--skirt", help = "end of range", default=0)
    args = parser.parse_args()

    F = np.load("custom_utils/smpl_faces" + ("_skirt" if args.skirt == 1 else "") + ".npy")
    uv_map = np.load('custom_utils/stretched_uv_map_' + ("skirt" if args.skirt == 1 else "3") + '.npy')
    m2uv = np.load('custom_utils/m2uv' + ("_skirt" if args.skirt == 1 else "") + '.npy', allow_pickle=True).item()
    m2uv = m2uv_array(m2uv)
    uv_mask = np.load('custom_utils/mask_256x512' + ("_skirt" if args.skirt == 1 else "") + '.npy')
    curvature_label_type = '6_25 '

    uv_res = 256
    uv_mask = (cv2.resize(uv_mask * 255.0, (uv_res, uv_res * 2)) / 255).astype(bool)[:, :, np.newaxis]
    # uv_mask_dilate = cv2.erode(uv_mask.astype(np.float32), cv2.getStructuringElement(cv2.MORPH_CROSS, (2 * 2 + 1, 2 * 2 + 1), (2, 2)), iterations=1).astype(bool)[:, :, np.newaxis]
    # uv_mask_border = uv_mask * np.invert(uv_mask_dilate)
    uv_mask = cv2.dilate(uv_mask.astype(np.float32), cv2.getStructuringElement(cv2.MORPH_RECT, (2 * 2 + 1, 2 * 2 + 1), (2, 2)), iterations=2).astype(bool)[:, :, np.newaxis]

    uv_map_discreet = np.floor(uv_map * uv_res).astype(np.int32)
    uv_map_mask = unique_uv_map_mask(uv_map_discreet)

    uv_counter = np.zeros((uv_map.shape[0]))
    uv_counter[m2uv[:, 0]] = 1
    uv_counter[m2uv[:, 1]] += 1
    uv_counter = uv_counter[uv_map_mask]

    uv_map_discreet_unique = uv_map_discreet[uv_map_mask, :]

    rbf_dest = np.ones((uv_res * 2, uv_res))
    rbf_dest[uv_map_discreet_unique[:, 0], uv_map_discreet_unique[:, 1]] = 0
    rbf_dest[np.invert(uv_mask[:,:,0])] = 0


    #########################################################################################

    use_no_orient = False
    no_shape = False
    is_skirt = True if args.skirt == 1 else False
    folder = args.folder
    neighbourhood = 25
    frames_file = 'frames_all.txt'
    data_to_convert = ['mesh_posed', 'mesh_static', 'mesh_curvature', 'body_posed'] # 'mesh_unposed',

    print("skirt" if args.skirt == 1 else "not skirt")
    print(f'params: -f {args.folder} -s {args.start} -e {args.end} -n {args.name} -skirt {args.skirt}')

    skirt_modifier = '_skirt' if is_skirt else ''
    orient_mod = '_no_orient' if use_no_orient else ''
    shape_mod = '_no_shape' if no_shape else ''

    frames = []
    with open(os.path.join(folder, frames_file), 'r') as f:
        lines = f.readlines()
        lines = [line.strip() for line in lines]
    frames = lines[int(args.start):int(args.end)]
    ids = [frame.split()[0] for frame in frames]
    ids = sorted(list(set(ids)))

    shapedirs = get_shapedirs()

    root = '/'.join(folder.split('/')[:-1])
    type = folder.split('/')[-1]
    # h5file_curv = tb.open_file(os.path.join(root, f'{type}_extras.h5'), mode='r')
    # h5file = tb.open_file(os.path.join(root, f'{type}_extras_uv.h5'), mode='a')

    extras_folder = os.path.join(root, f'{type}_extras')
    os.makedirs(extras_folder, exist_ok=True)
    os.makedirs(os.path.join(extras_folder, 'uv_posed' + orient_mod), exist_ok=True)
    os.makedirs(os.path.join(extras_folder, 'uv_static'), exist_ok=True)
    os.makedirs(os.path.join(extras_folder, 'uv_curvature'), exist_ok=True)
    os.makedirs(os.path.join(extras_folder, 'uv_unposed'), exist_ok=True)
    os.makedirs(os.path.join(extras_folder, 'uv_body_posed' + orient_mod), exist_ok=True)
    os.makedirs(os.path.join(extras_folder, 'uv_mask'), exist_ok=True)


    for id in tqdm.tqdm(ids):


        info = loadInfo(os.path.join(folder, id, 'info.mat'))
        garments = list(info['outfit'].keys())
        assert info['poses'].shape[1] <= 300

        # put all this in a function and call for all garments

        # also masking is not the same as just filling the empty values with neighbouring
        # values, at least the plots are different

        for garment in garments:
        # garment = garments[0]

            # if all the uv maps have been generated, skip this id
            # if all([os.path.exists(os.path.join(extras_folder, 'uv_body_posed' + orient_mod,  f'{id}_{i}_{garment}.npz')) for i in range(info['poses'].shape[1])]):
            #     continue

            mask = read_garment_mask(folder, id, garment)

            if 'mesh_posed' in data_to_convert:
                # mesh_posed_frame = read_posed_garment_frame(folder, id, garment, 0, mask=mask, shape=info['shape'], pose=info['poses'][:,0], deorient=use_no_orient, unshape=no_shape)
                mesh_posed = read_posed_garment(folder, id, garment, mask=mask, shape=info['shape'], poses=info['poses'], deorient=use_no_orient, unshape=no_shape)
            if 'mesh_unposed' in data_to_convert:
                raise NotImplementedError()
                mesh_unposed = read_unposed_garment(folder, id, garment, mask=mask, shape=info['shape'], unshape=no_shape)
            if 'mesh_static' in data_to_convert:
                mesh_static = read_garment_template(folder, id, garment, mask)
            if 'mesh_curvature' in data_to_convert:
                mesh_curvature = read_curvatures(folder + '_extras', id, garment, count=info['poses'].shape[1])
            if 'body_posed' in data_to_convert:
                body_posed = read_posed_body(folder, id, info['poses'], use_no_orient)


            start = time.perf_counter()

            uv_static, uv_mask_local, garment_uv_mask_border = convert_to_uv(uv_res, m2uv, uv_map, mesh_static, neighbours=3, mask=mask, method='rbf', garment_uv_mask=None)
            uv_static = convert_to_uv_batch(uv_res, m2uv, uv_map, mesh_static[None, :, :], neighbours=3, mask=mask, method='rbf', garment_uv_mask=uv_mask_local, garment_uv_mask_border=garment_uv_mask_border)
            uv_static = uv_static.astype(np.float32)

            if 'mesh_posed' in data_to_convert:
                uv_posed = convert_to_uv_batch(uv_res, m2uv, uv_map, mesh_posed[:, :, :], neighbours=3, mask=mask, method='rbf', garment_uv_mask=uv_mask_local, garment_uv_mask_border=garment_uv_mask_border)
            if 'mesh_unposed' in data_to_convert:
                raise NotImplementedError()
                uv_unposed = convert_to_uv_batch(uv_res, m2uv, uv_map, mesh_unposed[:, :, :], neighbours=3, mask=mask, method='rbf', garment_uv_mask=uv_mask_local, garment_uv_mask_border=garment_uv_mask_border)
            if 'mesh_curvature' in data_to_convert:
                uv_curvature = convert_to_uv_batch_label(uv_res, m2uv, uv_map, mesh_curvature[:, :], neighbours=3, mask=mask, method='nearest', garment_uv_mask=uv_mask_local, garment_uv_mask_border=garment_uv_mask_border)
            if 'body_posed' in data_to_convert:
                uv_body_posed = convert_to_uv_batch_body(uv_res, m2uv, uv_map, body_posed[:, :, :], neighbours=3, mask=None, method='rbf', garment_uv_mask=None, garment_uv_mask_border=garment_uv_mask_border)



            print(time.perf_counter() - start)

            # mesh_static
            # save_to_h5file(h5file, id, 0, garment, uv_static, 'uv_static', 'float32')
            # save_to_h5file(h5file, id, 0, garment, uv_mask, 'uv_mask', 'float32')
            np.savez_compressed(os.path.join(extras_folder, 'uv_static',  f'{id}_{garment}.npz'), uv_static=uv_static)
            np.savez_compressed(os.path.join(extras_folder, 'uv_mask',  f'{id}_{garment}.npz'), uv_mask=uv_mask_local)

            if 'mesh_posed' in data_to_convert:
                for i in range(len(uv_posed)):
                    np.savez_compressed(os.path.join(extras_folder, 'uv_posed' + orient_mod,  f'{id}_{i}_{garment}.npz'), uv_posed=uv_posed[i])
                    # save_to_h5file(h5file, id, i, garment, uv_posed[i, :, :, :], 'uv_posed' + orient_mod + shape_mod, 'float32')
            if 'mesh_unposed' in data_to_convert:
                raise NotImplementedError()
                for i in range(uv_unposed.shape[0]):
                    save_to_h5file(h5file, id, i, garment, uv_unposed[i, :, :, :], 'uv_unposed' + orient_mod + shape_mod, 'float32')
            if 'mesh_curvature' in data_to_convert:
                for i in range(len(uv_curvature)):
                    np.savez_compressed(os.path.join(extras_folder, 'uv_curvature',  f'{id}_{i}_{garment}.npz'), uv_curvature=uv_curvature[i].astype(np.uint8))
                    # save_to_h5file(h5file, id, i, garment, uv_curvature[i, :, :, :], 'uv_curvature', 'uint8')
            if 'body_posed' in data_to_convert:
                for i in range(len(uv_body_posed)):
                    np.savez_compressed(os.path.join(extras_folder, 'uv_body_posed' + orient_mod,  f'{id}_{i}_{garment}.npz'), uv_body_posed=uv_body_posed[i])
                    # save_to_h5file(h5file, id, i, garment, uv_body_posed[i, :, :, :], 'uv_body_posed', 'float32')
            
            pass


    h5file_curv.close()