DUV_Utils_backup.py

import bpy
import bmesh
import math
from mathutils import Vector


def get_face_pixel_step(context, face):
    """
    Finds the UV space amount for one pixel of a face, if it is textured
    :param context:
    :param face:
    :return: Vector of the pixel translation, None if face is not textured
    """
    # Try to get the material being applied to the face
    slot_len = len(context.object.material_slots)
    if face.material_index < 0 or face.material_index >= slot_len:
        return None
    material = context.object.material_slots[face.material_index].material
    if material is None:
        return None
    # Try to get the texture the material is using
    target_img = None
    for texture_slot in material.texture_slots:
        if texture_slot is None:
            continue
        if texture_slot.texture is None:
            continue
        if texture_slot.texture.type == 'NONE':
            continue
        if texture_slot.texture.image is None:
            continue
        if texture_slot.texture.type == 'IMAGE':
            target_img = texture_slot.texture.image
            break
    if target_img is None:
        return None
    # With the texture in hand, save the UV step for one pixel movement
    pixel_step = Vector((1 / target_img.size[0], 1 / target_img.size[1]))
    return pixel_step

def get_orientation(context):
    obj = bpy.context.view_layer.objects.active
    bm = bmesh.from_edit_mesh(obj.data)
    uv_layer = bm.loops.layers.uv.verify()
    faces = list()
    #MAKE FACE LIST
    for face in bm.faces:
        if face.select:
            faces.append(face)
    
    for face in faces:
        xmin, xmax = face.loops[0][uv_layer].uv.x, face.loops[0][uv_layer].uv.x
        ymin, ymax = face.loops[0][uv_layer].uv.y, face.loops[0][uv_layer].uv.y

    for vert in face.loops:
        xmin = min(xmin, vert[uv_layer].uv.x)
        xmax = max(xmax, vert[uv_layer].uv.x)
        ymin = min(ymin, vert[uv_layer].uv.y)
        ymax = max(ymax, vert[uv_layer].uv.y)

    # corners:
    # 3 2
    # 0 1

    bound0 = Vector((xmin,ymin))
    bound1 = Vector((xmax,ymin))
    bound2 = Vector((xmax,ymax))
    bound3 = Vector((xmin,ymax))
    middle = Vector(( ((xmax+xmin)/2)- bound0.x,((ymax+ymin)/2)-bound0.y ))

    distance = middle.length
    corner0 = faces[0].loops[0]
    for f in faces:
        for loop in f.loops:
            loop_uv = loop[uv_layer]
            vertuv = Vector((loop_uv.uv.x - bound0.x,loop_uv.uv.y - bound0.y))
            tempdistance = vertuv.length
            if tempdistance <= distance:
                distance = tempdistance
                corner0 = loop

    distance = middle.length
    corner1 = faces[0].loops[0]
    for f in faces:
        for loop in f.loops:
            loop_uv = loop[uv_layer]
            vertuv = Vector((loop_uv.uv.x - bound1.x,loop_uv.uv.y - bound1.y))
            tempdistance = vertuv.length
            if tempdistance <= distance:
                distance = tempdistance
                corner1 = loop

    distance = middle.length
    corner2 = faces[0].loops[0]
    for f in faces:
        for loop in f.loops:
            loop_uv = loop[uv_layer]
            vertuv = Vector((loop_uv.uv.x - bound2.x,loop_uv.uv.y - bound2.y))
            tempdistance = vertuv.length
            if tempdistance <= distance:
                distance = tempdistance
                corner2 = loop

    distance = middle.length
    corner3 = faces[0].loops[0]
    for f in faces:
        for loop in f.loops:
            loop_uv = loop[uv_layer]
            vertuv = Vector((loop_uv.uv.x - bound3.x,loop_uv.uv.y - bound3.y))
            tempdistance = vertuv.length
            if tempdistance <= distance:
                distance = tempdistance
                corner3 = loop


    #orientations:
    # 3 2   0 3   1 0   2 1
    # 0 1   1 2   2 3   3 0  

    #1st case:
    #if corner3.vert.co.z >= corner0.vert.co.z and corner2.vert.co.z >= corner1.vert.co.z and corner3.vert.co.z >= corner1.vert.co.z and corner2.vert.co.z >= corner0.vert.co.z:
        #print("case1")
    
    if corner0.vert.co.z >= corner1.vert.co.z and corner3.vert.co.z >= corner2.vert.co.z and corner0.vert.co.z >= corner2.vert.co.z and corner3.vert.co.z >= corner1.vert.co.z:
        #print("case2")
        for face in faces:
            for loop in face.loops:
                newx = loop[uv_layer].uv.y
                newy = -loop[uv_layer].uv.x 
                loop[uv_layer].uv.x = newx
                loop[uv_layer].uv.y = newy

    if corner1.vert.co.z >= corner2.vert.co.z and corner0.vert.co.z >= corner3.vert.co.z and corner1.vert.co.z >= corner3.vert.co.z and corner0.vert.co.z >= corner2.vert.co.z:
        #print("case3")
        for face in faces:
            for loop in face.loops:
                newx = -loop[uv_layer].uv.x
                newy = -loop[uv_layer].uv.y 
                loop[uv_layer].uv.x = newx
                loop[uv_layer].uv.y = newy

    if corner2.vert.co.z >= corner3.vert.co.z and corner1.vert.co.z >= corner0.vert.co.z and corner2.vert.co.z >= corner0.vert.co.z and corner1.vert.co.z >= corner3.vert.co.z:
        #print("case4")
        for face in faces:
            for loop in face.loops:
                newx = -loop[uv_layer].uv.y
                newy = loop[uv_layer].uv.x 
                loop[uv_layer].uv.x = newx
                loop[uv_layer].uv.y = newy

    return None
    

def get_uv_ratio(context):
    #figure out uv size to then compare against subrect size
    #to do this I project the mesh using uv coords so i can calculate the area using sum(f.calc_area(). Because I am too lazy to figure out the math
    #this code is terrible, someone who knows math make this better, thanks
    obj = bpy.context.view_layer.objects.active
    bm = bmesh.from_edit_mesh(obj.data)
    uv_layer = bm.loops.layers.uv.verify()
    faces = list()
    #MAKE FACE LIST
    for face in bm.faces:
        if face.select:
            faces.append(face)
    backupfaces = list()
    for f in faces:
        backupface = list()
        for loop in f.loops:
            loop_uv = loop[uv_layer]
            backupvert = list()
            backupvert.append(loop.vert.co.x)
            backupvert.append(loop.vert.co.y)
            backupvert.append(loop.vert.co.z)
            backupface.append(backupvert)
        backupfaces.append(backupface)
    for f in faces:
        for loop in f.loops:
            loop_uv = loop[uv_layer]
            loop.vert.co.xy = loop_uv.uv
            loop.vert.co.z = 0 
    size = area = sum(f.calc_area() for f in faces if f.select)

    #return shape:
    for f, backupface in zip(faces, backupfaces):
        for loop, backupvert in zip(f.loops, backupface):
            loop.vert.co.x = backupvert[0]
            loop.vert.co.y = backupvert[1]
            loop.vert.co.z = backupvert[2]
    #bmesh.update_edit_mesh(obj.data)
    return size

def read_atlas(context):
    atlas = list()
    obj = context.scene.subrect_atlas
    me = obj.data
    bm = bmesh.new()
    bm.from_mesh(me)
    uv_layer = bm.loops.layers.uv.verify()
    #lets read coords

    faces = list()

    #MAKE FACE LIST
    for face in bm.faces:
        faces.append(face)

    for face in faces:
        xmin, xmax = face.loops[0][uv_layer].uv.x, face.loops[0][uv_layer].uv.x
        ymin, ymax = face.loops[0][uv_layer].uv.y, face.loops[0][uv_layer].uv.y

        for vert in face.loops:
            xmin = min(xmin, vert[uv_layer].uv.x)
            xmax = max(xmax, vert[uv_layer].uv.x)
            ymin = min(ymin, vert[uv_layer].uv.y)
            ymax = max(ymax, vert[uv_layer].uv.y)

        new_subrect = subrect()
        edge1 = xmax - xmin
        edge2 = ymax - ymin

        
        rect = list()
        
        for loop in face.loops:
            loop_uv = loop[uv_layer]
            #make sure to create new uv vector here, dont reference
            uvcoord = Vector((loop_uv.uv.x,loop_uv.uv.y))
            rect.append(uvcoord)
        
        new_subrect.uvcoord = rect
        
        #calculate aspect ratio
        if edge1 > 0 and edge2 > 0:

            aspect = edge1/edge2
            if aspect > 1:
                aspect = round(aspect)
            else:
                aspect = 1/(round(1/aspect))
                #aspect = 1/aspect
            posaspect = aspect
            if posaspect < 1.0:
                posaspect = 1/posaspect
            #calculate size
            size = face.calc_area()

            #adjust scale
            size /= context.scene.duvhotspotscale*context.scene.duvhotspotscale

            size = float('%.2g' % size) #round to 2 significant digits

            


            new_subrect.aspect = aspect
            new_subrect.posaspect = posaspect
            new_subrect.size = size
            atlas.append(new_subrect)   

    #print("atlas")
    #print(atlas)
    #for a in atlas:
    #    print(a.posaspect)
    return atlas



def square_fit(context):
    obj = bpy.context.view_layer.objects.active
    bm = bmesh.from_edit_mesh(obj.data)

    uv_layer = bm.loops.layers.uv.verify()

    faces = list()

    #MAKE FACE LIST
    for face in bm.faces:
        if face.select:
            faces.append(face)

    #TEST IF QUADS OR NOT

    quadmethod = True
    #EXPERIMENTAL! TO MUCH SKEWING TEST:
    distorted = False

    for face in faces: 
        if len(face.loops) != 4 :
            quadmethod = False
            print('no quad!')
    if quadmethod:
        print('quad!')

    #SLOW HERE, find faster way to test if selection is ring shaped

    #Unwrap and get the edge verts
    bmesh.update_edit_mesh(obj.data)
    bpy.ops.uv.unwrap(method='CONFORMAL', margin=0.001)
    bpy.ops.mesh.region_to_loop()

    obj = bpy.context.edit_object
    me = obj.data
    bm = bmesh.from_edit_mesh(me)

    edge_list = list()
    for e in bm.edges:
        if e.select is True and e.seam is False:
            edge_list.append(e)
            #print(e)
    
    #print("edge list")
    #print(edge_list)

    #select faces again
    for f in faces:
        f.select = True      
    #get start loop (this makes sure we loop in the right direction)

    #add seams to edge list also?
    for e in bm.edges:
        if e.seam is True:
            print("seam")
            for f in e.link_faces:
                print("seam faces:")
                print(f.select)
                if f.select is True:
                    print("adding seam")
                    edge_list.append(e)


    startloop = None

    if(len(edge_list) == 0):
        print("weird! - means no mesh was sent?")
        return distorted 

    for l in edge_list[0].link_loops:
        if l.face.select is True:
            startloop = l
    #create sorted verts from start loop
    sorted_vert_list = list()
    for f in faces:
        f.select = False
    for e in edge_list:
        e.select = True



    sorted_vert_list.append(startloop.vert)
    startloop.edge.select = False
    sorted_vert_list.append(startloop.link_loop_next.vert)

    #for i in range(1,len(edge_list)-1):

        #catch if a patch is donut shaped:
        #if i >= len(sorted_vert_list):
        #    for f in faces:
        #        f.select = True
        #    bmesh.update_edit_mesh(obj.data)
        #    print("donut shape")
        #    break

        #note: make it take a turn here when finding a seam!


    #    for e in sorted_vert_list[i].link_edges:
    #        if e.select is True:
    #            sorted_vert_list.append(e.other_vert(sorted_vert_list[i]))
    #            e.select = False

    nextvert = startloop.link_loop_next.vert
    i = 1
    while sorted_vert_list[i] is not startloop.vert or i == 500:



        #note: make it take a turn here when finding a seam!
        for e in sorted_vert_list[i].link_edges:
            if e.select is True:
                sorted_vert_list.append(e.other_vert(sorted_vert_list[i]))
                e.select = False 




        i += 1
    sorted_vert_list.pop() #remove last item which is the same as the first anyways
    print(sorted_vert_list)





    #select faces again
    for f in faces:
        f.select = True

    #get UV
    sorted_uv_list = list()
    uv_layer = bm.loops.layers.uv.active
    for v in sorted_vert_list:
        for l in v.link_loops:
            if l.face.select is True:
                sorted_uv_list.append(l[uv_layer])
                break

    #get all angles
    sorted_angle_list = list()

    for i in range(len(sorted_uv_list)):
        prev = (i-1)%len(sorted_uv_list)
        next = (i+1)%len(sorted_uv_list)
        vector1 = Vector((sorted_uv_list[prev].uv.y-sorted_uv_list[i].uv.y,sorted_uv_list[prev].uv.x-sorted_uv_list[i].uv.x))
        vector2 = Vector((sorted_uv_list[next].uv.y-sorted_uv_list[i].uv.y,sorted_uv_list[next].uv.x-sorted_uv_list[i].uv.x))
        #check failcase of zero length vector:
        if vector1.length == 0 or vector2.length == 0:
            bmesh.update_edit_mesh(obj.data)
            print("zero vector")
            return False
        angle = -math.degrees(vector1.angle_signed(vector2))
        if angle < 0:
            angle += 360
        sorted_angle_list.append(angle)

    
    #find concaves:
    for i in range(len(sorted_angle_list)):
        #print(sorted_angle_list[i])
        if sorted_angle_list[i] > 230:
            distorted = True
            print("distorted!")
            bmesh.update_edit_mesh(obj.data)
            return False

    #angle test:
    #print("angles")
    #test if more than 4 90 degrees:
    NCount = 0
    for i in range(len(sorted_angle_list)):
        #print(sorted_angle_list[i])
        if sorted_angle_list[i] < 100:
            NCount += 1
    if NCount > 4:
        distorted = True
        print("distorted2!")

    #now find top 4 angles
    topangles = list()
    for o in range(4):
        top = 360
        topindex = -1
        for i in range(len(sorted_angle_list)):
            if sorted_angle_list[i] < top:
                top = sorted_angle_list[i]
                topindex = i
        #print(sorted_angle_list[topindex])
        
        if o == 3:
            if sorted_angle_list[topindex] > 120:
                distorted = True
                print("distorted3!")

        topangles.append(topindex)
        sorted_angle_list[topindex] = 999 #lol

    sorted_corner_list = list()
    for i in range(len(sorted_uv_list)):
        sorted_corner_list.append(False)
    sorted_corner_list[topangles[0]] = True
    sorted_corner_list[topangles[1]] = True
    sorted_corner_list[topangles[2]] = True
    sorted_corner_list[topangles[3]] = True


    




    #find bottom left corner (using distance method seems to work well)
    distance = 2
    closest = 0
    for t in topangles:
        l = sorted_uv_list[t].uv.length
        if l < distance:
            distance = l
            closest = t

    #rotate lists to get clostest corner at start:
    for i in range(closest):
        sorted_corner_list.append(sorted_corner_list.pop(0))
        sorted_uv_list.append(sorted_uv_list.pop(0))
        sorted_vert_list.append(sorted_vert_list.pop(0))

    #print("THESE ARE THE CORNERS")
    #print(sorted_corner_list)
    #create coord list:

    cornerz = list()

    for i in range(len(sorted_vert_list)):
        if sorted_corner_list[i] is True:
            #print(sorted_vert_list[i].co.z)
            cornerz.append(sorted_vert_list[i].co.z)

    #print(cornerz)
    #avgedge1 = cornerz[0] + cornerz[1]
    #avgedge2 = cornerz[0] + cornerz[3]
    #print(avgedge1)
    #print(avgedge2)




    sorted_edge_ratios = list()

    #get edge lenghts
    edge = list()
    for i in range(len(sorted_vert_list)):
        if sorted_corner_list[i] is True:
            sorted_edge_ratios.append(0)
            if i != 0:
                l = (sorted_vert_list[i-1].co.xyz - sorted_vert_list[i].co.xyz).length
                edge.append(sorted_edge_ratios[i-1] + l)
            
        if sorted_corner_list[i] is False:
            l = (sorted_vert_list[i-1].co.xyz - sorted_vert_list[i].co.xyz).length
            sorted_edge_ratios.append(sorted_edge_ratios[i-1] + l)
        if i is (len(sorted_vert_list)-1):
            l = (sorted_vert_list[i].co.xyz - sorted_vert_list[0].co.xyz).length
            edge.append(sorted_edge_ratios[i] + l)

    
    if quadmethod: 
        print("running quadmethod")
    #MAP FIRST QUAD
        edge1 = (faces[0].loops[0].vert.co.xyz - faces[0].loops[1].vert.co.xyz).length
        edge2 = (faces[0].loops[1].vert.co.xyz - faces[0].loops[2].vert.co.xyz).length

        faces[0].loops[0][uv_layer].uv.x = 0
        faces[0].loops[0][uv_layer].uv.y = 0
        faces[0].loops[1][uv_layer].uv.x = edge1
        faces[0].loops[1][uv_layer].uv.y = 0
        faces[0].loops[2][uv_layer].uv.x = edge1
        faces[0].loops[2][uv_layer].uv.y = edge2
        faces[0].loops[3][uv_layer].uv.x = 0
        faces[0].loops[3][uv_layer].uv.y = edge2

        bm.faces.active = faces[0]

        #UNWRAP ADJACENT
        bmesh.update_edit_mesh(obj.data)
        bpy.ops.uv.follow_active_quads()
        obj = bpy.context.view_layer.objects.active
        bm = bmesh.from_edit_mesh(obj.data)
        uv_layer = bm.loops.layers.uv.verify()

        #return
        edge1 = (edge[0]+edge[2])*.5
        edge2 = (edge[1]+edge[3])*.5

        #FIT TO 0-1 range
        xmin, xmax = faces[0].loops[0][uv_layer].uv.x, faces[0].loops[0][uv_layer].uv.x
        ymin, ymax = faces[0].loops[0][uv_layer].uv.y, faces[0].loops[0][uv_layer].uv.y

        for face in faces: 
            for vert in face.loops:
                xmin = min(xmin, vert[uv_layer].uv.x)
                xmax = max(xmax, vert[uv_layer].uv.x)
                ymin = min(ymin, vert[uv_layer].uv.y)
                ymax = max(ymax, vert[uv_layer].uv.y)

        #return

        #prevent divide by 0:
        if (xmax - xmin) == 0:
            xmin = .1
        if (ymax - ymin) == 0:
            ymin = .1

        for face in faces:
            for loop in face.loops:
                loop[uv_layer].uv.x -= xmin
                loop[uv_layer].uv.y -= ymin
                loop[uv_layer].uv.x /= (xmax-xmin)
                loop[uv_layer].uv.y /= (ymax-ymin)
        
        #shift extents to be positive only:
        xmax = xmax - xmin
        ymax = ymax - ymin

        #now fit to correct edge lengths:
        if (edge1 < edge2):
            #flip them:
            tedge = edge1
            edge1 = edge2
            edge2 = tedge
        
        if xmax >= ymax:
            for face in faces:
                for loop in face.loops:
                    loop[uv_layer].uv.x *= edge1
                    loop[uv_layer].uv.y *= edge2
        if xmax < ymax:
            for face in faces:
                for loop in face.loops:
                    loop[uv_layer].uv.x *= edge2
                    loop[uv_layer].uv.y *= edge1

        bmesh.update_edit_mesh(obj.data)


    if quadmethod is False:
        print("not running quadmethod")
        

        if distorted is False:
            #NOW LAY OUT ALL EDGE UVs
            i = 0
            #EDGE 1
            for l in sorted_vert_list[i].link_loops:
                if l.face.select is True:
                    l[uv_layer].uv = Vector((0,0))
            i += 1
            while sorted_corner_list[i] is False:
                for l in sorted_vert_list[i].link_loops:
                    if l.face.select is True:
                        l[uv_layer].uv = Vector((sorted_edge_ratios[i]/edge[0],0)) 
                i += 1 
            #EDGE 2
            for l in sorted_vert_list[i].link_loops:
                if l.face.select is True:
                    l[uv_layer].uv = Vector((1,0))        
            i += 1
            while sorted_corner_list[i] is False:
                for l in sorted_vert_list[i].link_loops:
                    if l.face.select is True:
                        l[uv_layer].uv = Vector((1,sorted_edge_ratios[i]/edge[1])) 
                i += 1     
            #EDGE 3
            for l in sorted_vert_list[i].link_loops:
                if l.face.select is True:
                    l[uv_layer].uv = Vector((1,1))         
            i += 1
            while sorted_corner_list[i] is False:
                for l in sorted_vert_list[i].link_loops:
                    if l.face.select is True:
                        l[uv_layer].uv = Vector((1-(sorted_edge_ratios[i]/edge[2]),1)) 
                i += 1
            #EDGE 4
            for l in sorted_vert_list[i].link_loops:
                if l.face.select is True:
                    l[uv_layer].uv = Vector((0,1))
            i += 1
            for o in range(i,len(sorted_vert_list)):
                for l in sorted_vert_list[o].link_loops:
                    if l.face.select is True:
                        l[uv_layer].uv = Vector((0,1-(sorted_edge_ratios[o]/edge[3])))

            #set proper aspect ratio
        
            for f in bm.faces:
                if f.select is True:
                    for loop in f.loops:
                        loop_uv = loop[uv_layer]
                        loop_uv.uv.x *= edge[0]
                        loop_uv.uv.y *= edge[1]

        bmesh.update_edit_mesh(me, True)
        bpy.ops.uv.select_all(action='SELECT')
        #expand middle verts
        bpy.ops.uv.minimize_stretch(iterations=100)   
        #return true if rect fit was succesful
        return not distorted     


class subrect:
    aspect = int()
    posaspect = int()
    size = float()
    uvcoord = list()

class trim:
    uvcoord = list()