neulab/docprompting-conala huggingface dataset:
skimage.data.human_mitosis() [source]
 
Image of human cells undergoing mitosis.  Returns 
 human_mitosis: (512, 512) uint8 ndimage

Data of human cells undergoing mitosis taken during the preperation of the manuscript in [1].     Notes Copyright David Root. Licensed under CC-0 [2]. References  
1  
Moffat J, Grueneberg DA, Yang X, Kim SY, Kloepfer AM, Hinkle G, Piqani B, Eisenhaure TM, Luo B, Grenier JK, Carpenter AE, Foo SY, Stewart SA, Stockwell BR, Hacohen N, Hahn WC, Lander ES, Sabatini DM, Root DE (2006) A lentiviral RNAi library for human and mouse genes applied to an arrayed viral high-content screen. Cell, 124(6):1283-98 / :DOI: 10.1016/j.cell.2006.01.040 PMID 16564017  
2  
GitHub licensing discussion https://github.com/CellProfiler/examples/issues/41
skimage.data.immunohistochemistry() [source]
 
Immunohistochemical (IHC) staining with hematoxylin counterstaining. This picture shows colonic glands where the IHC expression of FHL2 protein is revealed with DAB. Hematoxylin counterstaining is applied to enhance the negative parts of the tissue. This image was acquired at the Center for Microscopy And Molecular Imaging (CMMI). No known copyright restrictions.  Returns 
 
immunohistochemistry(512, 512, 3) uint8 ndarray 

Immunohistochemistry image.
skimage.data.kidney() [source]
 
Mouse kidney tissue. This biological tissue on a pre-prepared slide was imaged with confocal fluorescence microscopy (Nikon C1 inverted microscope). Image shape is (16, 512, 512, 3). That is 512x512 pixels in X-Y, 16 image slices in Z, and 3 color channels (emission wavelengths 450nm, 515nm, and 605nm, respectively). Real-space voxel size is 1.24 microns in X-Y, and 1.25 microns in Z. Data type is unsigned 16-bit integers.  Returns 
 
kidney(16, 512, 512, 3) uint16 ndarray 

Kidney 3D multichannel image.     Notes This image was acquired by Genevieve Buckley at Monasoh Micro Imaging in 2018. License: CC0
skimage.data.lbp_frontal_face_cascade_filename() [source]
 
Return the path to the XML file containing the weak classifier cascade. These classifiers were trained using LBP features. The file is part of the OpenCV repository [1]. References  
1  
OpenCV lbpcascade trained files https://github.com/opencv/opencv/tree/master/data/lbpcascades
skimage.data.lfw_subset() [source]
 
Subset of data from the LFW dataset. This database is a subset of the LFW database containing:  100 faces 100 non-faces  The full dataset is available at [2].  Returns 
 
images(200, 25, 25) uint8 ndarray 

100 first images are faces and subsequent 100 are non-faces.     Notes The faces were randomly selected from the LFW dataset and the non-faces were extracted from the background of the same dataset. The cropped ROIs have been resized to a 25 x 25 pixels. References  
1  
Huang, G., Mattar, M., Lee, H., & Learned-Miller, E. G. (2012). Learning to align from scratch. In Advances in Neural Information Processing Systems (pp. 764-772).  
2  
http://vis-www.cs.umass.edu/lfw/
skimage.data.lily() [source]
 
Lily of the valley plant stem. This plant stem on a pre-prepared slide was imaged with confocal fluorescence microscopy (Nikon C1 inverted microscope). Image shape is (922, 922, 4). That is 922x922 pixels in X-Y, with 4 color channels. Real-space voxel size is 1.24 microns in X-Y. Data type is unsigned 16-bit integers.  Returns 
 
lily(922, 922, 4) uint16 ndarray 

Lily 2D multichannel image.     Notes This image was acquired by Genevieve Buckley at Monasoh Micro Imaging in 2018. License: CC0
skimage.data.logo() [source]
 
Scikit-image logo, a RGBA image.  Returns 
 
logo(500, 500, 4) uint8 ndarray 

Logo image.
skimage.data.microaneurysms() [source]
 
Gray-level “microaneurysms” image. Detail from an image of the retina (green channel). The image is a crop of image 07_dr.JPG from the High-Resolution Fundus (HRF) Image Database: https://www5.cs.fau.de/research/data/fundus-images/  Returns 
 
microaneurysms(102, 102) uint8 ndarray 

Retina image with lesions.     Notes No copyright restrictions. CC0 given by owner (Andreas Maier). References  
1  
Budai, A., Bock, R, Maier, A., Hornegger, J., Michelson, G. (2013). Robust Vessel Segmentation in Fundus Images. International Journal of Biomedical Imaging, vol. 2013, 2013. DOI:10.1155/2013/154860
skimage.data.moon() [source]
 
Surface of the moon. This low-contrast image of the surface of the moon is useful for illustrating histogram equalization and contrast stretching.  Returns 
 
moon(512, 512) uint8 ndarray 

Moon image.
skimage.data.page() [source]
 
Scanned page. This image of printed text is useful for demonstrations requiring uneven background illumination.  Returns 
 
page(191, 384) uint8 ndarray 

Page image.
skimage.data.retina() [source]
 
Human retina. This image of a retina is useful for demonstrations requiring circular images.  Returns 
 
retina(1411, 1411, 3) uint8 ndarray 

Retina image in RGB.     Notes This image was downloaded from wikimedia. This file is made available under the Creative Commons CC0 1.0 Universal Public Domain Dedication. References  
1  
Häggström, Mikael (2014). “Medical gallery of Mikael Häggström 2014”. WikiJournal of Medicine 1 (2). DOI:10.15347/wjm/2014.008. ISSN 2002-4436. Public Domain
skimage.data.rocket() [source]
 
Launch photo of DSCOVR on Falcon 9 by SpaceX. This is the launch photo of Falcon 9 carrying DSCOVR lifted off from SpaceX’s Launch Complex 40 at Cape Canaveral Air Force Station, FL.  Returns 
 
rocket(427, 640, 3) uint8 ndarray 

Rocket image.     Notes This image was downloaded from SpaceX Photos. The image was captured by SpaceX and released in the public domain.
skimage.data.shepp_logan_phantom() [source]
 
Shepp Logan Phantom.  Returns 
 
phantom(400, 400) float64 image 

Image of the Shepp-Logan phantom in grayscale.     References  
1  
L. A. Shepp and B. F. Logan, “The Fourier reconstruction of a head section,” in IEEE Transactions on Nuclear Science, vol. 21, no. 3, pp. 21-43, June 1974. DOI:10.1109/TNS.1974.6499235
skimage.data.skin() [source]
 
Microscopy image of dermis and epidermis (skin layers). Hematoxylin and eosin stained slide at 10x of normal epidermis and dermis with a benign intradermal nevus.  Returns 
 
skin(960, 1280, 3) RGB image of uint8 
   Notes This image requires an Internet connection the first time it is called, and to have the pooch package installed, in order to fetch the image file from the scikit-image datasets repository. The source of this image is https://en.wikipedia.org/wiki/File:Normal_Epidermis_and_Dermis_with_Intradermal_Nevus_10x.JPG The image was released in the public domain by its author Kilbad.
skimage.data.stereo_motorcycle() [source]
 
Rectified stereo image pair with ground-truth disparities. The two images are rectified such that every pixel in the left image has its corresponding pixel on the same scanline in the right image. That means that both images are warped such that they have the same orientation but a horizontal spatial offset (baseline). The ground-truth pixel offset in column direction is specified by the included disparity map. The two images are part of the Middlebury 2014 stereo benchmark. The dataset was created by Nera Nesic, Porter Westling, Xi Wang, York Kitajima, Greg Krathwohl, and Daniel Scharstein at Middlebury College. A detailed description of the acquisition process can be found in [1]. The images included here are down-sampled versions of the default exposure images in the benchmark. The images are down-sampled by a factor of 4 using the function skimage.transform.downscale_local_mean. The calibration data in the following and the included ground-truth disparity map are valid for the down-sampled images: Focal length:           994.978px
Principal point x:      311.193px
Principal point y:      254.877px
Principal point dx:      31.086px
Baseline:               193.001mm
  Returns 
 
img_left(500, 741, 3) uint8 ndarray 

Left stereo image.  
img_right(500, 741, 3) uint8 ndarray 

Right stereo image.  
disp(500, 741, 3) float ndarray 

Ground-truth disparity map, where each value describes the offset in column direction between corresponding pixels in the left and the right stereo images. E.g. the corresponding pixel of img_left[10, 10 + disp[10, 10]] is img_right[10, 10]. NaNs denote pixels in the left image that do not have ground-truth.     Notes The original resolution images, images with different exposure and lighting, and ground-truth depth maps can be found at the Middlebury website [2]. References  
1  
D. Scharstein, H. Hirschmueller, Y. Kitajima, G. Krathwohl, N. Nesic, X. Wang, and P. Westling. High-resolution stereo datasets with subpixel-accurate ground truth. In German Conference on Pattern Recognition (GCPR 2014), Muenster, Germany, September 2014.  
2  
http://vision.middlebury.edu/stereo/data/scenes2014/
skimage.data.text() [source]
 
Gray-level “text” image used for corner detection.  Returns 
 
text(172, 448) uint8 ndarray 

Text image.     Notes This image was downloaded from Wikipedia <https://en.wikipedia.org/wiki/File:Corner.png>`__. No known copyright restrictions, released into the public domain.
skimage.draw.bezier_curve(r0, c0, r1, c1, r2, c2, weight, shape=None) [source]
 
Generate Bezier curve coordinates.  Parameters 
 
r0, c0int 

Coordinates of the first control point.  
r1, c1int 

Coordinates of the middle control point.  
r2, c2int 

Coordinates of the last control point.  
weightdouble 

Middle control point weight, it describes the line tension.  
shapetuple, optional 

Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for curves that exceed the image size. If None, the full extent of the curve is used.    Returns 
 
rr, cc(N,) ndarray of int 

Indices of pixels that belong to the Bezier curve. May be used to directly index into an array, e.g. img[rr, cc] = 1.     Notes The algorithm is the rational quadratic algorithm presented in reference [1]. References  
1  
A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012 http://members.chello.at/easyfilter/Bresenham.pdf   Examples >>> import numpy as np
>>> from skimage.draw import bezier_curve
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> rr, cc = bezier_curve(1, 5, 5, -2, 8, 8, 2)
>>> img[rr, cc] = 1
>>> img
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
       [0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
       [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
skimage.draw.circle(r, c, radius, shape=None) [source]
 
Generate coordinates of pixels within circle.  Parameters 
 
r, cdouble 

Center coordinate of disk.  
radiusdouble 

Radius of disk.  
shapetuple, optional 

Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for disks that exceed the image size. If None, the full extent of the disk is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.    Returns 
 
rr, ccndarray of int 

Pixel coordinates of disk. May be used to directly index into an array, e.g. img[rr, cc] = 1.    Warns 
 Deprecated:

 New in version 0.17: This function is deprecated and will be removed in scikit-image 0.19. Please use the function named disk instead.
skimage.draw.circle_perimeter(r, c, radius, method='bresenham', shape=None) [source]
 
Generate circle perimeter coordinates.  Parameters 
 
r, cint 

Centre coordinate of circle.  
radiusint 

Radius of circle.  
method{‘bresenham’, ‘andres’}, optional 

bresenham : Bresenham method (default) andres : Andres method  
shapetuple, optional 

Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for circles that exceed the image size. If None, the full extent of the circle is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.    Returns 
 
rr, cc(N,) ndarray of int 

Bresenham and Andres’ method: Indices of pixels that belong to the circle perimeter. May be used to directly index into an array, e.g. img[rr, cc] = 1.     Notes Andres method presents the advantage that concentric circles create a disc whereas Bresenham can make holes. There is also less distortions when Andres circles are rotated. Bresenham method is also known as midpoint circle algorithm. Anti-aliased circle generator is available with circle_perimeter_aa. References  
1  
J.E. Bresenham, “Algorithm for computer control of a digital plotter”, IBM Systems journal, 4 (1965) 25-30.  
2  
E. Andres, “Discrete circles, rings and spheres”, Computers & Graphics, 18 (1994) 695-706.   Examples >>> from skimage.draw import circle_perimeter
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> rr, cc = circle_perimeter(4, 4, 3)
>>> img[rr, cc] = 1
>>> img
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
       [0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
       [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
       [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
       [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
       [0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
skimage.draw.circle_perimeter_aa(r, c, radius, shape=None) [source]
 
Generate anti-aliased circle perimeter coordinates.  Parameters 
 
r, cint 

Centre coordinate of circle.  
radiusint 

Radius of circle.  
shapetuple, optional 

Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for circles that exceed the image size. If None, the full extent of the circle is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.    Returns 
 
rr, cc, val(N,) ndarray (int, int, float) 

Indices of pixels (rr, cc) and intensity values (val). img[rr, cc] = val.     Notes Wu’s method draws anti-aliased circle. This implementation doesn’t use lookup table optimization. Use the function draw.set_color to apply circle_perimeter_aa results to color images. References  
1  
X. Wu, “An efficient antialiasing technique”, In ACM SIGGRAPH Computer Graphics, 25 (1991) 143-152.   Examples >>> from skimage.draw import circle_perimeter_aa
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> rr, cc, val = circle_perimeter_aa(4, 4, 3)
>>> img[rr, cc] = val * 255
>>> img
array([[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0],
       [  0,   0,  60, 211, 255, 211,  60,   0,   0,   0],
       [  0,  60, 194,  43,   0,  43, 194,  60,   0,   0],
       [  0, 211,  43,   0,   0,   0,  43, 211,   0,   0],
       [  0, 255,   0,   0,   0,   0,   0, 255,   0,   0],
       [  0, 211,  43,   0,   0,   0,  43, 211,   0,   0],
       [  0,  60, 194,  43,   0,  43, 194,  60,   0,   0],
       [  0,   0,  60, 211, 255, 211,  60,   0,   0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0]], dtype=uint8)
 >>> from skimage import data, draw
>>> image = data.chelsea()
>>> rr, cc, val = draw.circle_perimeter_aa(r=100, c=100, radius=75)
>>> draw.set_color(image, (rr, cc), [1, 0, 0], alpha=val)
skimage.draw.disk(center, radius, *, shape=None) [source]
 
Generate coordinates of pixels within circle.  Parameters 
 
centertuple 

Center coordinate of disk.  
radiusdouble 

Radius of disk.  
shapetuple, optional 

Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for disks that exceed the image size. If None, the full extent of the disk is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.    Returns 
 
rr, ccndarray of int 

Pixel coordinates of disk. May be used to directly index into an array, e.g. img[rr, cc] = 1.     Examples >>> from skimage.draw import disk
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> rr, cc = disk((4, 4), 5)
>>> img[rr, cc] = 1
>>> img
array([[0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 1, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
       [0, 1, 1, 1, 1, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
skimage.draw.ellipse(r, c, r_radius, c_radius, shape=None, rotation=0.0) [source]
 
Generate coordinates of pixels within ellipse.  Parameters 
 
r, cdouble 

Centre coordinate of ellipse.  
r_radius, c_radiusdouble 

Minor and major semi-axes. (r/r_radius)**2 + (c/c_radius)**2 = 1.  
shapetuple, optional 

Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for ellipses which exceed the image size. By default the full extent of the ellipse are used. Must be at least length 2. Only the first two values are used to determine the extent.  
rotationfloat, optional (default 0.) 

Set the ellipse rotation (rotation) in range (-PI, PI) in contra clock wise direction, so PI/2 degree means swap ellipse axis    Returns 
 
rr, ccndarray of int 

Pixel coordinates of ellipse. May be used to directly index into an array, e.g. img[rr, cc] = 1.     Notes The ellipse equation: ((x * cos(alpha) + y * sin(alpha)) / x_radius) ** 2 +
((x * sin(alpha) - y * cos(alpha)) / y_radius) ** 2 = 1
 Note that the positions of ellipse without specified shape can have also, negative values, as this is correct on the plane. On the other hand using these ellipse positions for an image afterwards may lead to appearing on the other side of image, because image[-1, -1] = image[end-1, end-1] >>> rr, cc = ellipse(1, 2, 3, 6)
>>> img = np.zeros((6, 12), dtype=np.uint8)
>>> img[rr, cc] = 1
>>> img
array([[1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1]], dtype=uint8)
 Examples >>> from skimage.draw import ellipse
>>> img = np.zeros((10, 12), dtype=np.uint8)
>>> rr, cc = ellipse(5, 6, 3, 5, rotation=np.deg2rad(30))
>>> img[rr, cc] = 1
>>> img
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
       [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
       [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
skimage.draw.ellipse_perimeter(r, c, r_radius, c_radius, orientation=0, shape=None) [source]
 
Generate ellipse perimeter coordinates.  Parameters 
 
r, cint 

Centre coordinate of ellipse.  
r_radius, c_radiusint 

Minor and major semi-axes. (r/r_radius)**2 + (c/c_radius)**2 = 1.  
orientationdouble, optional 

Major axis orientation in clockwise direction as radians.  
shapetuple, optional 

Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for ellipses that exceed the image size. If None, the full extent of the ellipse is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.    Returns 
 
rr, cc(N,) ndarray of int 

Indices of pixels that belong to the ellipse perimeter. May be used to directly index into an array, e.g. img[rr, cc] = 1.     References  
1  
A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012 http://members.chello.at/easyfilter/Bresenham.pdf   Examples >>> from skimage.draw import ellipse_perimeter
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> rr, cc = ellipse_perimeter(5, 5, 3, 4)
>>> img[rr, cc] = 1
>>> img
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
       [0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
       [0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
       [0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
       [0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
       [0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
 Note that the positions of ellipse without specified shape can have also, negative values, as this is correct on the plane. On the other hand using these ellipse positions for an image afterwards may lead to appearing on the other side of image, because image[-1, -1] = image[end-1, end-1] >>> rr, cc = ellipse_perimeter(2, 3, 4, 5)
>>> img = np.zeros((9, 12), dtype=np.uint8)
>>> img[rr, cc] = 1
>>> img
array([[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
       [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
       [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
       [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
       [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]], dtype=uint8)
skimage.draw.ellipsoid(a, b, c, spacing=(1.0, 1.0, 1.0), levelset=False) [source]
 
Generates ellipsoid with semimajor axes aligned with grid dimensions on grid with specified spacing.  Parameters 
 
afloat 

Length of semimajor axis aligned with x-axis.  
bfloat 

Length of semimajor axis aligned with y-axis.  
cfloat 

Length of semimajor axis aligned with z-axis.  
spacingtuple of floats, length 3 

Spacing in (x, y, z) spatial dimensions.  
levelsetbool 

If True, returns the level set for this ellipsoid (signed level set about zero, with positive denoting interior) as np.float64. False returns a binarized version of said level set.    Returns 
 
ellip(N, M, P) array 

Ellipsoid centered in a correctly sized array for given spacing. Boolean dtype unless levelset=True, in which case a float array is returned with the level set above 0.0 representing the ellipsoid.
skimage.draw.ellipsoid_stats(a, b, c) [source]
 
Calculates analytical surface area and volume for ellipsoid with semimajor axes aligned with grid dimensions of specified spacing.  Parameters 
 
afloat 

Length of semimajor axis aligned with x-axis.  
bfloat 

Length of semimajor axis aligned with y-axis.  
cfloat 

Length of semimajor axis aligned with z-axis.    Returns 
 
volfloat 

Calculated volume of ellipsoid.  
surffloat 

Calculated surface area of ellipsoid.
skimage.draw.line(r0, c0, r1, c1) [source]
 
Generate line pixel coordinates.  Parameters 
 
r0, c0int 

Starting position (row, column).  
r1, c1int 

End position (row, column).    Returns 
 
rr, cc(N,) ndarray of int 

Indices of pixels that belong to the line. May be used to directly index into an array, e.g. img[rr, cc] = 1.     Notes Anti-aliased line generator is available with line_aa. Examples >>> from skimage.draw import line
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> rr, cc = line(1, 1, 8, 8)
>>> img[rr, cc] = 1
>>> img
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)