anaglyph_algorithm.Anaglyph Class Reference

This class represents an algorithm to compute two stereo images from gimp layers and to combine them to an anaglyph. More...

Public Member Functions
def	__init__ (self, f1=1.0, f2=1.0)
	Creates an anaglyph algorithm. More...
def	shiftx (self, img, d)
	Helper function to shift an image with a given disparity value. More...
def	shiftx_ext (self, img, d)
	Helper function to shift an image with a given disparity map. More...
def	update (self, layer_data, d)
	Update the image using a single depth value. More...
def	update_ext (self, layer_data, d)
	Update the image using a depth map. More...
def	get_result (self, swap_lr)
	Combines the result collected so far (left and right image) as anaglyph. More...

Public Attributes
	f1
	f2
	imsum
	left
	right
	aleft
	aright

Detailed Description

This class represents an algorithm to compute two stereo images from gimp layers and to combine them to an anaglyph.

Definition at line 34 of file anaglyph_algorithm.py.

Constructor & Destructor Documentation

def anaglyph_algorithm.Anaglyph.__init__	(		self,
			f1 = 1.0,
			f2 = 1.0
	)

Creates an anaglyph algorithm.

Parameters

f1	the darkening factor for the left image (1.0 = no modification)
f2	the darkening factor for the left image (1.0 = no modification)

Definition at line 36 of file anaglyph_algorithm.py.

    def __init__(self, f1=1.0, f2=1.0):
        """! Creates an anaglyph algorithm.
        @param f1 the darkening factor for the left image (1.0 = no modification)
        @param f2 the darkening factor for the left image (1.0 = no modification)
        """
        self.f1=f1
        self.f2=f2
        self.imsum = None
        self.left  = None
        self.right = None
        self.aleft  = None
        self.aright = None

Member Function Documentation

def anaglyph_algorithm.Anaglyph.get_result	(		self,
			swap_lr
	)

Combines the result collected so far (left and right image) as anaglyph.

Parameters

swap_lr

if true the left and right image are swapped.

Returns

a numpy array representing the result image with 4 (RGBA) channels.

Definition at line 122 of file anaglyph_algorithm.py.

    def get_result(self,swap_lr):
        """! Combines the result collected so far (left and right image) as anaglyph. 
        @param swap_lr if true the left and right image are swapped.
        @return a numpy array representing the result image with 4 (RGBA) channels.
        """
        a = numpy.zeros((self.left.shape[0],self.left.shape[1],4))
        if swap_lr:
            r = self.left
            l = self.right
        else:
            l = self.left
            r = self.right            
        a[:,:,0] = l*self.f1 + (1-self.f1)/2
        a[:,:,1] = r*self.f2 + (1-self.f2)/2
        a[:,:,2] = r*self.f2 + (1-self.f2)/2
        a[:,:,3] = numpy.maximum(self.aleft,self.aright)
        return a

def anaglyph_algorithm.Anaglyph.shiftx	(		self,
			img,
			d
	)

Helper function to shift an image with a given disparity value.

Definition at line 49 of file anaglyph_algorithm.py.

    def shiftx(self,img,d):
        """! Helper function to shift an image with a given disparity value. """
        res = numpy.roll(img,d,axis=1)
        if (d>0):
            res[:,:d]=0
        elif (d<0):
            res[:,d:]=0
        return res

def anaglyph_algorithm.Anaglyph.shiftx_ext	(		self,
			img,
			d
	)

Helper function to shift an image with a given disparity map.

Definition at line 58 of file anaglyph_algorithm.py.

    def shiftx_ext(self,img,d):
        """! Helper function to shift an image with a given disparity map. """
        w = d.shape[1]
        h = d.shape[0]
        x,y = numpy.meshgrid(numpy.arange(w),numpy.arange(h))
        x = x-d
        res,m = interp2(x,y,img);
        return res*m
        

def anaglyph_algorithm.Anaglyph.update	(		self,
			layer_data,
			d
	)

Update the image using a single depth value.

Parameters

layer_data	the layer to be added (as numpy array)
d	the disparity of the layer

Definition at line 68 of file anaglyph_algorithm.py.

    def update(self, layer_data, d):
        """! Update the image using a single depth value
        @param layer_data the layer to be added (as numpy array)
        @param d the disparity of the layer
        """
        h = layer_data.shape[0]
        w = layer_data.shape[1]
        if layer_data.shape[2]==1:
            tmp = numpy.ones((h,w,2))*255.0
            tmp[:,:,1]=numpy.reshape(layer_data,(h,w))
            layer_data=tmp
        if self.left==None:
            self.left  = numpy.zeros((h,w))
            self.right = numpy.zeros((h,w))
            self.aleft  = numpy.zeros((h,w))
            self.aright = numpy.zeros((h,w))
        else:
            assert(self.left.shape == (h,w), "shape must not change")
            
        imleft  = self.shiftx(layer_data[:,:,0],-d)
        imright = self.shiftx(layer_data[:,:,0],+d)
        alphaleft  = self.shiftx(layer_data[:,:,1],-d)
        alpharight = self.shiftx(layer_data[:,:,1],+d)
   
        self.left  = (self.left *(255-alphaleft )+imleft *alphaleft )/255
        self.right = (self.right*(255-alpharight)+imright*alpharight)/255
        self.aleft  = numpy.maximum(alphaleft,  self.aleft)
        self.aright = numpy.maximum(alpharight, self.aright)

def anaglyph_algorithm.Anaglyph.update_ext	(		self,
			layer_data,
			d
	)

Update the image using a depth map.

Parameters

layer_data	the layer to be added (as numpy array)
d	the disparity map of the layer

Definition at line 97 of file anaglyph_algorithm.py.

    def update_ext(self, layer_data, d):
        """! Update the image using a depth map
        @param layer_data the layer to be added (as numpy array)
        @param d the disparity map of the layer
        """
        h = layer_data.shape[0]
        w = layer_data.shape[1]
        if self.left==None:
            self.left  = numpy.zeros((h,w))
            self.right = numpy.zeros((h,w))
            self.aleft  = numpy.zeros((h,w))
            self.aright = numpy.zeros((h,w))
        else:
            assert(self.left.shape == (h,w), "shape must not change")
            
        imleft  = self.shiftx_ext(layer_data[:,:,0],-d)
        imright = self.shiftx_ext(layer_data[:,:,0],+d)
        alphaleft  = self.shiftx_ext(layer_data[:,:,1],-d)
        alpharight = self.shiftx_ext(layer_data[:,:,1],+d)
   
        self.left  = (self.left *(255-alphaleft )+imleft *alphaleft )/255
        self.right = (self.right*(255-alpharight)+imright*alpharight)/255
        self.aleft  = numpy.maximum(alphaleft,  self.aleft)
        self.aright = numpy.maximum(alpharight, self.aright)

Member Data Documentation

anaglyph_algorithm.Anaglyph.aleft

Definition at line 46 of file anaglyph_algorithm.py.

anaglyph_algorithm.Anaglyph.aright

Definition at line 47 of file anaglyph_algorithm.py.

anaglyph_algorithm.Anaglyph.f1

Definition at line 41 of file anaglyph_algorithm.py.

anaglyph_algorithm.Anaglyph.f2

Definition at line 42 of file anaglyph_algorithm.py.

anaglyph_algorithm.Anaglyph.imsum

Definition at line 43 of file anaglyph_algorithm.py.

anaglyph_algorithm.Anaglyph.left

Definition at line 44 of file anaglyph_algorithm.py.

anaglyph_algorithm.Anaglyph.right

Definition at line 45 of file anaglyph_algorithm.py.

---

The documentation for this class was generated from the following file:

• /home/pierre/checkouts/create_anaglyph/plugin/anaglyph_algorithm.py