Converts this point to a Jacobian representation.

        Returns:
            JacobianPoint: The Jacobian representation.
343074
def to_jacobian(self):
        
        if not self:
            return JacobianPoint(X=0, Y=0, Z=0)
        return JacobianPoint(X=self.X, Y=self.Y, Z=1)
641217
def Jacobian_re_im(self, pars):
        
        """
        partials = []

        # partials.append(self.dre_dlog10rho0(pars)[:, np.newaxis, :])
        partials.append(self.dre_drho0(pars)[:, np.newaxis])
        partials.append(self.dre_dm(pars))
        # partials.append(self.dre_dlog10tau(pars))
        partials.append(self.dre_dtau(pars))
        partials.append(self.dre_dc(pars))
        # partials.append(self.dim_dlog10rho0(pars)[:, np.newaxis, :])
        partials.append(self.dim_drho0(pars)[:, np.newaxis])
        partials.append(self.dim_dm(pars))
        # partials.append(self.dim_dlog10tau(pars))
        partials.append(self.dim_dtau(pars))
        partials.append(self.dim_dc(pars))

        print('SHAPES')
        for x in partials:
            print(x.shape)

        J = np.concatenate(partials, axis=1)
        return J
643134
def points(self):
        
        x = vtk_to_numpy(self.GetXCoordinates())
        y = vtk_to_numpy(self.GetYCoordinates())
        z = vtk_to_numpy(self.GetZCoordinates())
        xx, yy, zz = np.meshgrid(x,y,z, indexing='ij')
        return np.c_[xx.ravel(), yy.ravel(), zz.ravel()]
940428
@Pure
	public Point3d getCurrentPoint() {
		Point3d point = new Point3d();
		point.xProperty = this.coordsProperty[this.numCoordsProperty.get()-3];
		point.yProperty = this.coordsProperty[this.numCoordsProperty.get()-2];
		point.zProperty = this.coordsProperty[this.numCoordsProperty.get()-1];

		return point;
	}
106982
def transform(point)
	    return point if point.is_a?(PointZero)
	    m = matrix
	    m ? Point[m * Point[point]] : point
	end
865409
def points(self):
        
        vtk_data = self.GetPoints().GetData()
        arr = vtk_to_numpy(vtk_data)
        return vtki_ndarray(arr, vtk_data)
497263
def adjoint(self):
        
        # TODO allow users to select what method to use here.
        div_op = Divergence(domain=self.displacement.space, method='forward',
                            pad_mode='symmetric')
        jacobian_det = self.domain.element(
            np.exp(-div_op(self.displacement)))

        return jacobian_det * self.inverse
546755
def convert_coordinates(self, points, axisorder='blr'):
        
        return convert_coordinates_sequence(points,self._boundary_scale,
                                            self._axis_limits, axisorder)
347107
function() {
                var newPoint = new BezierPoint(), tmp = null;
                tmp = this.getVertex();
                newPoint.setVertex(tmp.x, tmp.y);
                tmp = this.getForward();
                newPoint.setForward(tmp.x, tmp.y);
                tmp = this.getBackward();
                newPoint.setBackward(tmp.x, tmp.y);
                newPoint.setSymReflaction(this.isSymReflaction);
                newPoint.setSmooth(this.isSmooth());
                return newPoint;
            }
1017052
def points(self):
        
        points = matrix_to_points(matrix=self.matrix,
                                  pitch=self.pitch,
                                  origin=self.origin)
        return points
647646
def points(self):
        ''''''
        if self._points is None:
            _points = self.soma.points.tolist()
            for n in self.neurites:
                _points.extend(n.points.tolist())
            self._points = np.array(_points)

        return self._points
1342620
def _convert_point(cls, feature):
        """"""
        lon, lat = feature['geometry']['coordinates']
        popup = feature['properties'].get('name', '')
        return cls(lat, lon)
462104
public static PathPoint curveTo(float c0X, float c0Y, float c1X, float c1Y, float x, float y) {
        return new PathPoint(c0X,  c0Y, c1X, c1Y, x, y);
    }
1128707
def create_point(self, x, y):
        
        if (not isinstance(x, six.integer_types) or
                not isinstance(y, six.integer_types)):
            raise ValueError("The coordinates must be longs.")
        return _ECDSA_Point(SECP256k1.curve, x, y)
475006
public static Point transform (float x, float y, float sx, float sy, float sina, float cosa,
                                   float tx, float ty, Point result) {
        return result.set((x*cosa - y*sina) * sx + tx, (x*sina + y*cosa) * sy + ty);
    }
692075
def start_point(self):
        
        edge = self.result.wire().val().Edges()[0]
        return edge.Vertices()[0].Center()
403211
def points(self):
        
        if not self._points:
            self._points = MetricPoints(self.api_client)
        return self._points