depth_algorithm.DepthAlgo Class Reference

This class is responsible to compute the depth of a layer. More...

Public Member Functions
def	__init__ (self, gimp_image, mindisp, maxdisp)
	Creates a DepthAlgo. More...
def	is_depth_map (self, gimp_layer)
	Determines if a layer is a depth map. More...
def	has_map (self, gimp_layer)
def	has_reldepthmap (self, gimp_layer)
	Determines if a layer has (uses) a depth map as relative map (relative depth values between the neighboring layers) More...
def	has_fixdepthmap (self, gimp_layer)
	Determines if a layer has (uses) a depth map as fixed map fixed depth values) More...
def	has_depth (self, gimp_layer)
	Determines if a used depth is specified for the layer. More...
def	get_disparity (self, gimp_layer)
	Determines the depth value or the map of depth values of a layer. More...

Public Attributes
	gimp_image
	mindisp
	maxdisp
	n
	depthmaps
	normallayers

Detailed Description

This class is responsible to compute the depth of a layer.

This can be a single depth value or a depth map.

Definition at line 4 of file depth_algorithm.py.

Constructor & Destructor Documentation

def depth_algorithm.DepthAlgo.__init__	(		self,
			gimp_image,
			mindisp,
			maxdisp
	)

Creates a DepthAlgo.

Parameters

gimp_image	the gimp image to be processed
min_disp	the minimum disparity to be processed (relative to image width)
max_disp	the maximum disparity to be processed (relative to image width)

Definition at line 8 of file depth_algorithm.py.

    def __init__(self, gimp_image, mindisp, maxdisp):
        """!
        Creates a DepthAlgo.
        @param gimp_image the gimp image to be processed        
        @param min_disp the minimum disparity to be processed (relative to image width)        
        @param max_disp the maximum disparity to be processed (relative to image width)        
        """
        self.gimp_image = gimp_image
        self.mindisp = mindisp
        self.maxdisp = maxdisp
        self.n=0
        self.depthmaps={}
        self.normallayers=[]
        for layer in reversed(gimp_image.layers):
            m = self.is_depth_map(layer) 
            isnormal = not( m or self.has_fixdepthmap(layer) or self.has_depth(layer))
            if isnormal:
                #print("normal layer: %s --> %d"%(layer.name,self.n))
                self.n+=1
                self.normallayers.insert(0,layer)
            elif m:
                data = layer2array(layer, dtype=numpy.float)
                data = data[:,:,0]
                assert(data.max()>data.min())
                data = (data-data.min())/(data.max()-data.min())*1.0
                mi = float(m.group(2))
                ma = float(m.group(3))
                assert(ma>mi)
                self.depthmaps[m.group(1)] = mi+data*(ma-mi)
        #print("layer count n==%d"%(self.n))

Member Function Documentation

def depth_algorithm.DepthAlgo.get_disparity	(		self,
			gimp_layer
	)

Determines the depth value or the map of depth values of a layer.

Parameters

gimp_layer

the layer to be investigated. the depth value (as absolute disparity in pixels) either as single value or as array of values.

Definition at line 87 of file depth_algorithm.py.

    def get_disparity(self, gimp_layer):
        """! Determines the depth value or the map of depth values of a layer
        @param gimp_layer the layer to be investigated.
        @retrun the depth value (as absolute disparity in pixels) either as single value or as array of values.
        """
        idx = self.gimp_image.layers.index(gimp_layer) # raises exception on error
        mrel=self.has_reldepthmap(gimp_layer)
        mfix=self.has_fixdepthmap(gimp_layer)
        if self.n>1:
            d = float(idx)/float(self.n-1)
        else:
            d = 0
        if self.has_map(gimp_layer):
            if mrel:
                print("relative map detected: "+gimp_layer.name)
                d0 = d-float(1.0/(self.n-1))
                d1 = d+float(1.0/(self.n-1))
                assert(mrel.group(1) in self.depthmaps.keys())
                d = self.depthmaps[mrel.group(1)]
                d =  d0+d*(d1-d0)
            else:
                print("fixed map detected: "+gimp_layer.name)
                assert(mfix.group(1) in self.depthmaps.keys())
                d = self.depthmaps[mfix.group(1)]
            d = self.mindisp+float(self.maxdisp-self.mindisp)*d
            return numpy.floor(0.5+d*self.gimp_image.width/100.0)
        else:
            m=self.has_depth(gimp_layer)
            if (m):
                d = float(m.group(1))
                #print("detected fixed depth: %s=rel. %f"%(gimp_layer.name,d))
            else:
                idx = self.normallayers.index(gimp_layer) # raises exception on error
                if self.n>1:
                    d = float(idx)/float(self.n-1)
                else:
                    d = 0

            d = self.mindisp+float(self.maxdisp-self.mindisp)*d
            #print("***** depth, idx=%d, d=%f"%(idx,d))
            return int(0.5+d*self.gimp_image.width/100.0)
            

def depth_algorithm.DepthAlgo.has_depth	(		self,
			gimp_layer
	)

Determines if a used depth is specified for the layer.

Parameters

gimp_layer

the layer to be investigated.

Returns

the matcher containing the map depth (logically maps to a boolean)

Definition at line 75 of file depth_algorithm.py.

    def has_depth(self, gimp_layer):
        """! Determines if a used depth is specified for the layer
        @param gimp_layer the layer to be investigated.
        @return the matcher containing the map depth (logically maps to a boolean)
        """
        n=gimp_layer.name
        if (n.startswith("background")):
            n="depth=0" 
        pat = re.compile(r'depth=(-?[\d\.]+)')
        m=pat.match(n)
        return m

def depth_algorithm.DepthAlgo.has_fixdepthmap	(		self,
			gimp_layer
	)

Determines if a layer has (uses) a depth map as fixed map fixed depth values)

Parameters

gimp_layer

the layer to be investigated.

Returns

the matcher containing the map name or None (logically maps to a boolean)

Definition at line 66 of file depth_algorithm.py.

    def has_fixdepthmap(self, gimp_layer):
        """! Determines if a layer has (uses) a depth map as fixed map fixed depth values)
        @param gimp_layer the layer to be investigated.
        @return the matcher containing the map name or None (logically maps to a boolean)
        """
        pat = re.compile(r'fixdepthmap\s*=\s*(\w+)')
        m=pat.match(gimp_layer.name)
        return m

def depth_algorithm.DepthAlgo.has_map	(		self,
			gimp_layer
	)

Parameters

gimp_layer

the layer to be investigated.

Returns

if this layer has a depth map (or a single depth for the whole layer)

Definition at line 50 of file depth_algorithm.py.

    def has_map(self, gimp_layer):
        """! 
        @param gimp_layer the layer to be investigated.
        @return if this layer has a depth map (or a single depth for the whole layer)
        """
        return bool(self.has_reldepthmap(gimp_layer)) or bool(self.has_fixdepthmap(gimp_layer))

def depth_algorithm.DepthAlgo.has_reldepthmap	(		self,
			gimp_layer
	)

Determines if a layer has (uses) a depth map as relative map (relative depth values between the neighboring layers)

Parameters

gimp_layer

the layer to be investigated.

Returns

the matcher containing the map name or None (logically maps to a boolean)

Definition at line 57 of file depth_algorithm.py.

    def has_reldepthmap(self, gimp_layer):
        """! Determines if a layer has (uses) a depth map as relative map (relative depth values between the neighboring layers)
        @param gimp_layer the layer to be investigated.
        @return the matcher containing the map name or None (logically maps to a boolean)
        """
        pat = re.compile(r'reldepthmap\s*=\s*(\w+)')
        m=pat.match(gimp_layer.name)
        return m

def depth_algorithm.DepthAlgo.is_depth_map	(		self,
			gimp_layer
	)

Determines if a layer is a depth map.

Parameters

gimp_layer

the layer to be investigated.

Returns

the matcher containing (name, mindepth, maxdepth) or None (logically maps to a boolean)

Definition at line 40 of file depth_algorithm.py.

    def is_depth_map(self, gimp_layer):
        """!
        Determines if a layer is a depth map.
        @param gimp_layer the layer to be investigated.
        @return the matcher containing (name, mindepth, maxdepth) or None (logically maps to a boolean)
        """
        pat = re.compile(r'depthmap\s+(\w+)\s+(-?[\d\.]+)\s+to\s+(-?[\d\.]+)')
        m=pat.match(gimp_layer.name)
        return m

Member Data Documentation

depth_algorithm.DepthAlgo.depthmaps

Definition at line 19 of file depth_algorithm.py.

depth_algorithm.DepthAlgo.gimp_image

Definition at line 15 of file depth_algorithm.py.

depth_algorithm.DepthAlgo.maxdisp

Definition at line 17 of file depth_algorithm.py.

depth_algorithm.DepthAlgo.mindisp

Definition at line 16 of file depth_algorithm.py.

depth_algorithm.DepthAlgo.n

Definition at line 18 of file depth_algorithm.py.

depth_algorithm.DepthAlgo.normallayers

Definition at line 20 of file depth_algorithm.py.

---

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

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