#VectorTester

#VectorTester
from pymel.core import *
import maya.api.OpenMaya as om
import math
import time
import pymel.core.datatypes as dt
import maya.cmds as cmds

class thing():
    def __init__(self, thingObject):
        self.thingObj = thingObject
        self.pos = om.MVector(thingObject.getTranslation())
        self.dir = []

def grpr(name):
    g = ls(name)
    if g:
        delete(g)
    g = group(n=name,em=1)
    return g
def getDist(p1,p2):
    dist = math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2 + (p1[2] - p2[2])**2)
    return dist
def getCenter(p1,p2, offset):
    center = (p1 + -p1*offset) + p2*offset
    return center
def getCenter(p1,p2, offset):
    return (p1 + -p1*offset) + p2*offset
def adder(testPF, t):
    return (testPF[0]+t[0] , testPF[1]+t[1] ,testPF[2]+t[2])
def subber(testPF, t):
    return (testPF[0]-t[0] , testPF[1]-t[1] ,testPF[2]-t[2])
def setMag(testP, amnt):
    return (testP[0]*amnt , testP[1]*amnt ,testP[2]*amnt) # scaler
def getMag(testP):
    return math.sqrt(testP[0]**2 + testP[1]**2 + testP[2]**2) #magnitude
def makeNormal(vector, mag):
    return (vector[0]/mag ,vector[1]/mag,vector[2]/mag) #normalize
def scaler(testP, amnt):
    return (testP[0]*amnt , testP[1]*amnt ,testP[2]*amnt) # scaler
def scalerD(testP, amnt):
    return (testP[0]/amnt , testP[1]/amnt ,testP[2]/amnt) # scaler
def rVec(randAmnt):
    rV = om.MVector(r.uniform(-randAmnt,randAmnt),r.uniform(-randAmnt,randAmnt),r.uniform(-randAmnt,randAmnt))
    return rV


def angleBtw(a, b):
    return math.sqrt(((a.x-b.x)**2)+((a.y-b.y)**2)+((a.z-b.z)**2))


cleanGrp = grpr("lineGrp")

origin = om.MVector(0,0,0)

# Working objects
p1 = thing(ls("p1")[0])
p2 = thing(ls("p2")[0])
p3 = thing(ls("p3")[0])
target = thing(ls("target")[0])
goalObj = thing(ls("goalObj")[0])

rotatorObj = thing(ls("Rotator")[0])
rotatorObj2 = thing(ls("Rotator2")[0])


center = (p1.pos + p2.pos) /2
offsetAmnt = (target.pos - center)


# Vector displays
p1Vector = curve(p=[origin, p1.pos],d=1,n = "p1Vector")
p2Vector = curve(p=[origin, p2.pos],d=1,n = "p2Vector")
targetVector = curve(p=[origin, target.pos],d=1,n = "targetVector")
centerVector = curve(p=[origin, center],d=1,n = "centerVector")
offsetAmntVector = curve(p=[center+origin, center+offsetAmnt],d=1,n = "offsetAmntVector")
parent([p1Vector,p2Vector,targetVector, centerVector, offsetAmntVector], cleanGrp)
move(goalObj.thingObj ,center+offsetAmnt)
select(cl=1)

p1N = om.MVector(p1.pos)
p2N = om.MVector(p2.pos)
p1N.normalize()
p2N.normalize()

#rotTest = math.cos(p1.pos)
dot =  p1N*p2N
rotAmnt = math.acos(dot)* 180/math.pi
rotAmntS = math.acos(dot)* 180/math.pi



hypotenuse = getDist(p1.pos ,p2.pos)
opposite = getDist(p1.pos, p3.pos)
adjacent = getDist(p2.pos, p3.pos)
angleInRadians = acos((adjacent**2 + opposite**2 - hypotenuse**2)/(2 * opposite * hypotenuse))

print "hypotenuse ", hypotenuse
print "opposite ", opposite
print "adjacent ", adjacent
print "angleInRadians ", angleInRadians
print degrees(angleInRadians)

print "Dot: ", dot
print "acos: ",math.acos(dot)
print "sin: ",rotAmntS
print p1.pos.x
print "angle between ", angleBtw(p1.pos, p2.pos)

setAttr(rotatorObj.thingObj.rotateX, rotAmnt)
setAttr(rotatorObj2.thingObj.rotateX ,degrees(angleInRadians))