1/28/2014

(OpenCV Study) -1.#IND, check by cvIsNaN

-1.#IND is generated when sqrt(-1),
IND is abstract of "indeterminate"

To check this value, we can use cvIsNaN function
The function check the input value is indeterminate value or not.
If value is indeterminate value, the function return 1


show the example code

printf ("cvIsNaN (0.0) : %d\n",cvIsNaN (0.0));
printf ("cvIsNaN (1.0/0.0) : %d\n",cvIsNaN (1.0/0.0));
printf ("cvIsNaN (-1.0/0.0) : %d\n",cvIsNaN (-1.0/0.0));
printf ("cvIsNaN (sqrt(-1.0)): %d\n",cvIsNaN (sqrt(-1.0)));

output is
cvIsNaN (0.0)      : 0
cvIsNaN (1.0/0.0)  : 0
cvIsNaN (-1.0/0.0) : 0
cvIsNaN (sqrt(-1.0): 1


1/27/2014

(Python Study) about class (example source code)

__author__ = 'mare'



class MyClass:
 """ very simple class """
 pass

class Person:
 Name = "Default Name"
 def Print(self):
  print("My name is {0}".format( self.Name ))


p1 = Person()
p1.Print()
p1.Name = "yuna"
p1.Print()
#My name is Default Name
#My name is yuna


#class object and instance object namespace
class Person:
 name = "default name"

p1 = Person();
p2 = Person();

print("p1's name: ", p1.name)
print("p2's name: ", p2.name)
#p1's name:  default name
#p2's name:  default name

p1.name = "yuna kim"
print("p1's name: ", p1.name)
print("p2's name: ", p2.name)
#p1's name:  yuna kim
#p2's name:  default name

#new member create
Person.title = "new title"
print("p1's title: ", p1.title)
print("p2's title: ", p2.title)
#p1's title:  new title
# p2's title:  new title

print("Person's title: ", Person.title)
#Person's title:  new title

p1.age = 20
print("p1's age", p1.age)
#p1's age 20
#print("p2's age", p2.age)
#error!!!
#AttributeError: 'Person' object has no attribute 'age'


#notice self keyword
str = "Not class member"
class GString:
 str = ""
 def set(self, msg):
  self.str = msg
 def Print(self):
  print(str)

g = GString()
g.set("First Message")
g.Print()
#Not class member

#exception keyword, __class__

class Test:
 data = "Default"

i2 = Test();
i1 = Test();

i1.__class__.data = "all data will be changed"

print(i1.data)
print(i2.data)
#all data will be changed
#all data will be changed

i2.data = "only i2's data is changed"

print(i1.data)
print(i2.data)
#all data will be changed
#only i2's data is changed


#relationship class object and instance object

class Person:
 pass
class Bird:
 pass
class Student:
 pass

p, s = Person(), Student()
print( isinstance(p, Person) )
#True
print( isinstance(s, Person) )
print( isinstance(p, object) )
print( isinstance(p, Bird) )
print( isinstance(int, object) )
#False
#True
#False
#True

#creator and deleter
class MyClass:
 def __init__(self, value):
  self.Value = value
  print("Class is created! value = ", value)

 def __del__(self):
  print("Class is deleted")

def foo():
 d = MyClass(10)

foo()
#Class is created! value =  10
#Class is deleted



#static method, class method
class CounterManager:
 insCount = 0

 def __init__(self):
  CounterManager.insCount += 1

 def printInstanceCount():
  print("Instance Count: ", CounterManager.insCount)


a, b, c = CounterManager(), CounterManager(), CounterManager()

CounterManager.printInstanceCount()
#Instance Count:  3
#b.printInstanceCount()
#error

# rewrite rightly
print("---")
class CounterManager:
 insCount = 0

 def __init__(self):
  CounterManager.insCount += 1

 def staticPrintCount():
  print("Instance Count: ", CounterManager.insCount)

 SPrintCount = staticmethod(staticPrintCount)

 def classPrintCount(cls):
  print("Instance Count: ", cls.insCount)

 CPrintCount = classmethod(classPrintCount)

a, b, c = CounterManager(), CounterManager(), CounterManager()

CounterManager.SPrintCount()
b.SPrintCount()
CounterManager.CPrintCount()
b.CPrintCount()
#Instance Count:  3
#Instance Count:  3
#Instance Count:  3
#Instance Count:  3

#operator re define

class GString:

 def __init__(self, init=None):
  self.content = init

 def __add__(self, str):
  self.content += str;

 def __sub__(self, str):
  for i in str:
   self.content = self.content.replace(i, '')
  return GString(self.content)

 def __abs__(self):
  return GString( self.content.upper() )

 def Remove(self, str):
  return self.__sub__(str)

g = GString("abcdefgABCD")
print(g.content)
#abcdefgABCD

g+"Apple_"

print(g.content)
#abcdefgABCDApple_

g -= "ade"
print(g.content)
#bcfgABCDAppl_
g -= "QQQ"
print(g.content)
#bcfgABCDAppl_

g = abs(g)
print(g.content)
#BCFGABCDAPPL_


#sequence operator redefine

class Sequencer:
 def __init__(self, maxValue):
  self.maxValue = maxValue

 def __len__(self):
  return self.maxValue

 def __getitem__(self, index):
  if( 0 < index <= self.maxValue ):
   return index * 10
  else:
   raise IndexError("Index out of range")

 def __contains__(self, item):
  return (0 < item <= self.maxValue)

s = Sequencer(5)

print( s[1] )
print( s[3] )
print( [s[i] for i in range(1,6) ] )
#10
#30
#[10, 20, 30, 40, 50]

print( len(s) )
print( 3 in s )
print( 7 in s )
#5
#True
#False


#inheritance
class Person:
 " parent class "

 def __init__(self, name, phoneNumber):
  self.Name = name
  self.PhoneNumber = phoneNumber

 def PrintInfo(self):
  print("Info(Name:{0}, Phone Number: {1}".format(self.Name, self.PhoneNumber))

 def PrintPersonData(self):
  print("Person(Name:{0}, Phone Number:{1})".format(self.Name, self.PhoneNumber))

class Student(Person):
 "child class"

 def __init__(self, name, PhoneNumber, subject, studentID):
  self.Name = name
  self.PhoneNumber = PhoneNumber

  """ #call creator in parent class
  Person.__init__(self, name, phoneNumber)
  """

  self.Subject = subject
  self.StudentID = studentID

 #method addition
 def PrintStudentData(self):
  print("Student(subject: {0}, Student ID: {1})".format(self.Subject, self.StudentID))



p = Person("Derick", "010-123-4556")
s = Student("Marry", "010-123-2222", "Computer science", "990999")

print( p.__dict__ )
#{'Name': 'Derick', 'PhoneNumber': '010-123-4556'}

print( s.__dict__ )
#{'Subject': 'Computer science', 'Name': 'Marry', 'PhoneNumber': '010-123-2222', 'StudentID': '990999'}

print( issubclass(Student, Person) )
print( issubclass(Person, Student) )
print( issubclass(Person, Person) )
print( issubclass(Person, object))
print( issubclass(Student, object))
#True
#False
#True
#True
#True

print( s.PrintStudentData() )
#Student(subject: Computer science, Student ID: 990999)

print( dir(s) )


#Method overriding
class Student2(Person):
 "child class"

 def __init__(self, name, PhoneNumber, subject, studentID):
  self.Name = name
  self.PhoneNumber = PhoneNumber
  self.Subject = subject
  self.StudentID = studentID

 #method addition
 def PrintStudentData(self):
  print("Student(subject: {0}, Student ID: {1})".format(self.Subject, self.StudentID))

 def PrintInfo(self):
  print("Info(Name:{0}, Phone Number: {1}".format(self.Name, self.PhoneNumber))
  print("Student(subject: {0}, Student ID: {1})".format(self.Subject, self.StudentID))

s = Student2("Marry", "010-123-2222", "Computer science", "990999")
print( s.PrintInfo() )
#Info(Name:Marry, Phone Number: 010-123-2222
#Student(subject: Computer science, Student ID: 990999)


#method extension
class Student3(Person):
 "child class"

 def __init__(self, name, PhoneNumber, subject, studentID):
  self.Name = name
  self.PhoneNumber = PhoneNumber
  self.Subject = subject
  self.StudentID = studentID

 #method addition
 def PrintStudentData(self):
  print("Student(subject: {0}, Student ID: {1})".format(self.Subject, self.StudentID))

 def PrintInfo(self):
  Person.PrintInfo(self)
  print("Student(subject: {0}, Student ID: {1})".format(self.Subject, self.StudentID))

s = Student3("Marry", "010-123-2222", "Computer science", "990999")
print( s.PrintInfo() )
#Info(Name:Marry, Phone Number: 010-123-2222
#Student(subject: Computer science, Student ID: 990999)

#calss inheritance space and namespace
class SuperClass:
 x=10
 def printX(self):
  print(self.x)

class SubClass(SuperClass):
 y=20
 def printY(self):
  print(self.y)


s = SubClass()
s.a = 30

print( s.__dict__ )
#{'a': 30}
print( s.y )
print( s.x )
#20
#10


class SuperClass:
 x=10
 def printX(self):
  print(self.x)

class SubClass(SuperClass):
 y=20
 def printY(self):
  print(self.y)

 def printX(self):
  print("subClass:", self.x)

s = SubClass()

s.a = 30
s.x = 50

print("SuperClass: ", SuperClass.__dict__ )
print("SubClass: ", SubClass.__dict__ )
print("S: ", s.__dict__ )

"""
SuperClass:  {'__weakref__': , '__module__': '__main__', '__doc__': None, 'x': 10, '__dict__': , 'printX': }
SubClass:  {'__module__': '__main__', 'y': 20, '__doc__': None, 'printY': , 'printX': }
S:  {'a': 30, 'x': 50}
"""

#multi inheriance

class Tiger:
 def Jump(self):
  print(" jump far like tiger")

class Lion:
 def Bite(self):
  print("bite like lion")
 def Cry(self):
  print("zzzz")

class Liger(Tiger, Lion):
 def Play(self):
  print("play with liger")

l = Liger()
l.Jump()
l.Bite()
l.Play()
#jump far like tiger
#bite like lion
#play with liger

l.Cry()
#zzzz

class Animal:
 def __init__(self):
  print("Animal __init()")


class Tiger(Animal):

 def __init__(self):
  Animal.__init__(self)
  print("Tiger __init()")


class Lion(Animal):
 def __init__(self):
  Animal.__init__(self)
  print("Lion __init()")

class Liger(Tiger, Lion):

 def __init__(self):
  Tiger.__init__(self)
  Lion.__init__(self)
  print("liger __init()")


l = Liger()
#Animal __init()
#Tiger __init()
#Animal __init()
#Lion __init()
#liger __init()


# rewrite by super init
class Animal2:
 def __init__():
  print("Animal __init()")


class Tiger2(Animal):

 def __init__(self):
  super().__init__()
  print("Tiger __init()")


class Lion2(Animal):
 def __init__(self):
  super().__init__()
  print("Lion __init()")


class Liger2(Tiger2, Lion2):

 def __init__(self):
  super().__init__()
  print("liger __init()")

print("---")
l = Liger2()
#Animal __init()
#Lion __init()
#Tiger __init()
#liger __init()