Return this context’s target surface.

        :returns:
            An instance of :class:`Surface` or one of its sub-classes,
            a new Python object referencing the existing cairo surface.
519769
def get_target(self):
        
        return Surface._from_pointer(
            cairo.cairo_get_target(self._pointer), incref=True)
150167
def identity(self, surface):
        
        return self._pygame.transform.scale(surface, self._output_size)
804323
def get_dip(self):
        
        areas = self._get_areas()
        dips = numpy.array([surf.get_dip() for surf in self.surfaces])

        return numpy.sum(areas * dips) / numpy.sum(areas)
605527
def get_domain(self):
        
        if self.polyhedra != []:
            polyhedras_domain = np.vstack([poly.get_domain() 
                                          for poly in self.polyhedra])
        else:
            polyhedras_domain = np.ones((0, 3))
        points = np.vstack((self.surface.get_domain(), 
                            polyhedras_domain, 
                            self.set_of_points))
        return np.array([points.min(axis=0), points.max(axis=0)])
506608
def get_context_for_image(self, zoom):
        
        cairo_context = Context(self.__image)
        cairo_context.scale(zoom * self.multiplicator, zoom * self.multiplicator)
        return cairo_context
841163
def _get_reference(self):
        
        super()._get_reference()
        self.cubeA_body_id = self.sim.model.body_name2id("cubeA")
        self.cubeB_body_id = self.sim.model.body_name2id("cubeB")
        self.l_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.left_finger_geoms
        ]
        self.r_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.right_finger_geoms
        ]
        self.cubeA_geom_id = self.sim.model.geom_name2id("cubeA")
        self.cubeB_geom_id = self.sim.model.geom_name2id("cubeB")
613925
def surface(x, y, z):
    
    data = [go.Surface(x=x, y=y, z=z)]
    return Chart(data=data)
978499
def getInstance(self):
        
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance
817776
def copy(self):
        
        return self.__class__(self.x, self.y, *self._args, **self._kwargs)
321361
def get_target(cls, scheme, path, fragment, username,
                   password, hostname, port, query, **kwargs):
        
        raise NotImplementedError("get_target must be overridden")
716537
def _get_reference(self):
        
        super()._get_reference()
        self.cube_body_id = self.sim.model.body_name2id("cube")
        self.l_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.left_finger_geoms
        ]
        self.r_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.right_finger_geoms
        ]
        self.cube_geom_id = self.sim.model.geom_name2id("cube")
68363
def get_surface_boundaries(self):
        
        mesh = self.mesh
        lons = numpy.concatenate((mesh.lons[0, :],
                                  mesh.lons[1:, -1],
                                  mesh.lons[-1, :-1][::-1],
                                  mesh.lons[:-1, 0][::-1]))
        lats = numpy.concatenate((mesh.lats[0, :],
                                  mesh.lats[1:, -1],
                                  mesh.lats[-1, :-1][::-1],
                                  mesh.lats[:-1, 0][::-1]))
        return [lons], [lats]
928989
def surface_or_abstract(cls, predstr):
        """"""
        if predstr.strip('"').lstrip("'").startswith('_'):
            return cls.surface(predstr)
        else:
            return cls.abstract(predstr)
1166333
def target(self):
        """"""
        if self.pointsto is not None:
            #It is in the format of module.executable.
            xinst = self.module.parent.get_executable(self.pointsto.lower())
            return xinst
        else:
            #The executable it points to is the same as its name.
            fullname = "{}.{}".format(self.module.name, self.name)
            return self.module.parent.get_executable(fullname.lower())
1246469
def get_matrix(self):
        
        matrix = Matrix()
        cairo.cairo_pattern_get_matrix(self._pointer, matrix._pointer)
        self._check_status()
        return matrix
126420
def shape(self):
        
        if self.__x is not None:
            if self.isdiagonal:
                return (max(self.__x.shape), max(self.__x.shape))
            if len(self.__x.shape) == 1:
                raise Exception("Matrix.shape: Matrix objects must be 2D")
            return self.__x.shape
        return None
983860
def mesh_nmasked(self):
        

        return self._make_2d_array(
            np.ma.count_masked(self._data_sigclip, axis=1))