Add files using upload-large-folder tool

.gitattributes

@@ -884,3 +884,8 @@ infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/_skeletonize_variou
 infer_4_47_1/lib/python3.10/site-packages/skimage/filters/rank/core_cy_3d.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/_extrema_cy.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/_skeletonize_lee_cy.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/_grayreconstruct.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/_convex_hull.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/skimage/transform/_radon_transform.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/skimage/feature/_texture.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/skimage/transform/_hough_transform.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

infer_4_47_1/lib/python3.10/site-packages/skimage/data/README.txt

@@ -0,0 +1,9 @@
+This directory contains sample data from scikit-image.
+
+By default, it only contains a small subset of the entire dataset.
+
+The full detaset can be downloaded by using the following commands from
+a python console.
+
+  >>> from skimage.data import download_all
+  >>> download_all()

infer_4_47_1/lib/python3.10/site-packages/skimage/data/_registry.py

@@ -0,0 +1,184 @@
+# This minimal dataset was available as part of
+# scikit-image 0.15 and will be retained until
+# further notice.
+# Testing data and additional datasets should only
+# be made available by pooch
+legacy_datasets = [
+    'astronaut.png',
+    'brick.png',
+    'camera.png',
+    'chessboard_GRAY.png',
+    'chessboard_RGB.png',
+    'chelsea.png',
+    'clock_motion.png',
+    'coffee.png',
+    'coins.png',
+    'color.png',
+    'cell.png',
+    'grass.png',
+    'gravel.png',
+    'horse.png',
+    'hubble_deep_field.jpg',
+    'ihc.png',
+    'lbpcascade_frontalface_opencv.xml',
+    'lfw_subset.npy',
+    'logo.png',
+    'microaneurysms.png',
+    'moon.png',
+    'page.png',
+    'text.png',
+    'retina.jpg',
+    'rocket.jpg',
+    'phantom.png',
+    'motorcycle_disp.npz',
+    'motorcycle_left.png',
+    'motorcycle_right.png',
+]
+
+# Registry of datafiles that can be downloaded along with their SHA256 hashes
+# To generate the SHA256 hash, use the command
+# openssl sha256 filename
+registry = {
+    "color/tests/data/lab_array_a_10.npy": "a3ef76f1530e374f9121020f1f220bc89767dc866f4bbd1b1f47e5b84891a38c",
+    "color/tests/data/lab_array_a_2.npy": "793d5981cbffceb14b5fb589f998a2b1acdb5ff9c14d364c8e9e8bd45a80b275",
+    "color/tests/data/lab_array_a_r.npy": "3d3613da109d0c87827525fc49b58111aefc12438fa6426654979f66807b9227",
+    "color/tests/data/lab_array_b_10.npy": "e8d648b28077c1bfcef55ec6dc8679819612b56a01647f8c0a78625bb06f99b6",
+    "color/tests/data/lab_array_b_2.npy": "da9c6aa99e4ab3af8ec3107bbf11647cc483a0760285dd5c9fb66988be393ca1",
+    "color/tests/data/lab_array_b_r.npy": "d9eee96f4d65a2fbba82039508aac8c18304752ee8e33233e2a013e65bb91464",
+    "color/tests/data/lab_array_c_10.npy": "88b4ff2a2d2c4f48e7bb265609221d4b9ef439a4e2d8a86989696bfdb47790e6",
+    "color/tests/data/lab_array_c_2.npy": "e1b8acfdc7284ab9cd339de66948134304073b6f734ecf9ad42f8297b83d3405",
+    "color/tests/data/lab_array_c_r.npy": "09ffba2ed69e467864fea883493cd2d2706da028433464e3e858a8086842867e",
+    "color/tests/data/lab_array_d50_10.npy": "42e2ff26cb10e2a98fcf1bc06c2483302ff4fabf971fe8d49b530f490b5d24c7",
+    "color/tests/data/lab_array_d50_2.npy": "4aa03b7018ff7276643d3c082123cf07304f9d8d898ae92a5756a86955de4faf",
+    "color/tests/data/lab_array_d50_r.npy": "57db02009f9a68dade33ce1ecffead0418d8ac8113b2a589fc02a20e6bf7e799",
+    "color/tests/data/lab_array_d55_10.npy": "ab4f21368b6d8351578ab093381c44b49ae87a6b7f25c11aa094b07f215eed7d",
+    "color/tests/data/lab_array_d55_2.npy": "0319723de4632a252bae828b7c96d038fb075a7df05beadfbad653da05efe372",
+    "color/tests/data/lab_array_d55_r.npy": "060ebc446f7b4da4df58a60f0006133dbca735da87ba61854f4a75d28db67a3a",
+    "color/tests/data/lab_array_d65_10.npy": "5cb9e9c384d2577aaf8b7d2d21ff5b505708b80605a2f59d10e89d22c3d308d2",
+    "color/tests/data/lab_array_d65_2.npy": "16e847160f7ba4f19806d8194ed44a6654c9367e5a2cb240aa6e7eece44a6649",
+    "color/tests/data/lab_array_d65_r.npy": "82d0dd7a46741f627b8868793e64cdc2f9944fe1e049b573f752a93760a1577c",
+    "color/tests/data/lab_array_d75_10.npy": "c2d3de5422c785c925926b0c6223aeaf50b9393619d1c30830190d433606cbe1",
+    "color/tests/data/lab_array_d75_2.npy": "c94d53da398d36e076471ff7e0dafcaffc64ce4ba33b4d04849c32d19c87494a",
+    "color/tests/data/lab_array_e_2.npy": "ac05f17a83961b020ceccbdd46bddc86943d43e678dabcc898caf4a1e4be6165",
+    "color/tests/data/luv_array_a_10.npy": "c8af67f9fd64a6e9c610ac0c12c5315a49ca229363f048e5d851409d4a3ae5b6",
+    "color/tests/data/luv_array_a_2.npy": "eaf05dc61f4a70ece367d5e751a14d42b7c397c7b1c2df4cfecec9ddf26e1c1a",
+    "color/tests/data/luv_array_a_r.npy": "2c0891add787ec757601f9c61ad14dd9621dd969af4e32753f2e64df437081b7",
+    "color/tests/data/luv_array_b_10.npy": "a5407736b8a43071139ca178d12cdf930f32f52a0644f0b13f89d8895c8b43db",
+    "color/tests/data/luv_array_b_2.npy": "8e74173d54dc549b6c0ebd1f1d70489d2905cad87744e41ed74384f21f22986d",
+    "color/tests/data/luv_array_b_r.npy": "0a74c41df369cbb5fc0a00c16d60dc6f946ebf144bc5e506545b0d160fa53dfa",
+    "color/tests/data/luv_array_c_10.npy": "3a5f975ffa57f69a1be9e02b153e8161f83040ce3002ea1b0a05b9fbdd0d8ec4",
+    "color/tests/data/luv_array_c_2.npy": "32506cd50ea2181997cb88d3511e275740e8151d6c693cd178f5eafd8b0c6e47",
+    "color/tests/data/luv_array_c_r.npy": "c0fbf98cc0e62ed426ab4d228986d6660089444a7bbfcc64cbb1c632644067bb",
+    "color/tests/data/luv_array_d50_10.npy": "fe223db556222ce3a59198bed3a3324c2c719b8083fb84dc5b00f214b4773b16",
+    "color/tests/data/luv_array_d50_2.npy": "48e8989048904bdf2c3c1ada265c1c29c5eff60f02f848a25cde622982c84901",
+    "color/tests/data/luv_array_d50_r.npy": "f93f0def9c93f872dd10ce4a91fdb3f06eea61ddb6e72387b7669909827d4f9c",
+    "color/tests/data/luv_array_d55_10.npy": "d88d53d2bad230c2331442187712ec52ffdee62bf0f60b200c33411bfed76c60",
+    "color/tests/data/luv_array_d55_2.npy": "c761b40475df591ae9c0475d54ef712d067190ca4652efc6308b69080a652061",
+    "color/tests/data/luv_array_d55_r.npy": "05fbd57e3602ee4d5202b9f18f9b5fc05b545891a9b4456d2a88aa798a5a774a",
+    "color/tests/data/luv_array_d65_10.npy": "41a5452ffac4d31dd579d9528e725432c60d77b5f505d801898d9401429c89bf",
+    "color/tests/data/luv_array_d65_2.npy": "962ce180132c6c11798cbc423b2b204d1d10187670f6eb5dec1058eaad301e0e",
+    "color/tests/data/luv_array_d65_r.npy": "78db8c19af26dd802ce98b039a33855f7c8d6a103a2721d094b1d9c619717449",
+    "color/tests/data/luv_array_d75_10.npy": "e1cc70d56eb6789633d4c2a4059b9533f616a7c8592c9bd342403e41d72f45e4",
+    "color/tests/data/luv_array_d75_2.npy": "07db3bd59bd89de8e5ff62dad786fe5f4b299133495ba9bea30495b375133a98",
+    "color/tests/data/luv_array_e_2.npy": "41b1037d81b267305ffe9e8e97e0affa9fa54b18e60413b01b8f11861cb32213",
+    "color/tests/ciede2000_test_data.txt": "2e005c6f76ddfb7bbcc8f68490f1f7b4b4a2a4b06b36a80c985677a2799c0e40",
+    "data/astronaut.png": "88431cd9653ccd539741b555fb0a46b61558b301d4110412b5bc28b5e3ea6cb5",
+    "data/brick.png": "7966caf324f6ba843118d98f7a07746d22f6a343430add0233eca5f6eaaa8fcf",
+    "data/cell.png": "8d23a7fb81f7cc877cd09f330357fc7f595651306e84e17252f6e0a1b3f61515",
+    "data/camera.png": "b0793d2adda0fa6ae899c03989482bff9a42d3d5690fc7e3648f2795d730c23a",
+    "data/chessboard_GRAY.png": "3e51870774515af4d07d820bd8827364c70839bf9b573c746e485095e893df90",
+    "data/chessboard_RGB.png": "1ac01eff2d4e50f4eda55a2ddecdc28a6576623a58d7a7ef84513c5cc19a0331",
+    "data/chelsea.png": "596aa1e7cb875eb79f437e310381d26b338a81c2da23439704a73c4651e8c4bb",
+    "data/clock_motion.png": "f029226b28b642e80113d86622e9b215ee067a0966feaf5e60604a1e05733955",
+    "data/coffee.png": "cc02f8ca188b167c775a7101b5d767d1e71792cf762c33d6fa15a4599b5a8de7",
+    "data/coins.png": "f8d773fc9cfa6f4d8e5942dc34d0a0788fcaed2a4fefbbed0aef5398d7ef4cba",
+    "data/color.png": "7d2df993de2b4fa2a78e04e5df8050f49a9c511aa75e59ab3bd56ac9c98aef7e",
+    "data/eagle.png": "928f1bbe7403b533265f56db3a6b07c835dfa8e2513f5c5075ca2f1960f6179e",
+    "data/horse.png": "c7fb60789fe394c485f842291ea3b21e50d140f39d6dcb5fb9917cc178225455",
+    "data/grass.png": "b6b6022426b38936c43a4ac09635cd78af074e90f42ffa8227ac8b7452d39f89",
+    "data/hubble_deep_field.jpg": "3a19c5dd8a927a9334bb1229a6d63711b1c0c767fb27e2286e7c84a3e2c2f5f4",
+    "data/ihc.png": "f8dd1aa387ddd1f49d8ad13b50921b237df8e9b262606d258770687b0ef93cef",
+    "data/logo.png": "f2c57fe8af089f08b5ba523d95573c26e62904ac5967f4c8851b27d033690168",
+    "data/lfw_subset.npy": "9560ec2f5edfac01973f63a8a99d00053fecd11e21877e18038fbe500f8e872c",
+    "data/microaneurysms.png": "a1e1be59aa447f8ce082f7fa809997ab369a2b137cb6c4202abc647c7ccf6456",
+    "data/moon.png": "78739619d11f7eb9c165bb5d2efd4772cee557812ec847532dbb1d92ef71f577",
+    "data/motorcycle_left.png": "db18e9c4157617403c3537a6ba355dfeafe9a7eabb6b9b94cb33f6525dd49179",
+    "data/motorcycle_right.png": "5fc913ae870e42a4b662314bc904d1786bcad8e2f0b9b67dba5a229406357797",
+    "data/motorcycle_disp.npz": "2e49c8cebff3fa20359a0cc6880c82e1c03bbb106da81a177218281bc2f113d7",
+    "data/mssim_matlab_output.npz": "cc11a14bfa040c75b02db32282439f2e2e3e96779196c171498afaa70528ed7a",
+    "data/page.png": "341a6f0a61557662b02734a9b6e56ec33a915b2c41886b97509dedf2a43b47a3",
+    "data/phantom.png": "552ff698167aa402cceb17981130607a228a0a0aa7c519299eaa4d5f301ba36c",
+    "data/retina.jpg": "38a07f36f27f095e818aea7b96d34202c05176d30253c66733f2e00379e9e0e6",
+    "data/rocket.jpg": "c2dd0de7c538df8d111e479619b129464d0269d0ae5fd18ca91d33a7fdfea95c",
+    "data/gravel.png": "c48615b451bf1e606fbd72c0aa9f8cc0f068ab7111ef7d93bb9b0f2586440c12",
+    "data/text.png": "bd84aa3a6e3c9887850d45d606c96b2e59433fbef50338570b63c319e668e6d1",
+    "data/chessboard_GRAY_U16.tif": "9fd3392c5b6cbc5f686d8ff83eb57ef91d038ee0852ac26817e5ac99df4c7f45",
+    "data/chessboard_GRAY_U16B.tif": "b0a9270751f0fc340c90b8b615b62b88187b9ab5995942717566735d523cddb2",
+    "data/chessboard_GRAY_U8.npy": "71f394694b721e8a33760a355b3666c9b7d7fc1188ff96b3cd23c2a1d73a38d8",
+    "data/lbpcascade_frontalface_opencv.xml": "03097789a3dcbb0e40d20b9ef82537dbc3b670b6a7f2268d735470f22e003a91",
+    "data/astronaut_GRAY_hog_L1.npy": "5d8ab22b166d1dd49c12caeff9d178ed28132efea3852b952e9d75f7f7f94954",
+    "data/astronaut_GRAY_hog_L2-Hys.npy": "c4dd6e50d1129aada358311cf8880ce8c775f31e0e550fc322c16e43a96d56fe",
+    "data/rank_filter_tests.npz": "efaf5699630f4a53255e91681dc72a965acd4a8aa1f84671c686fb93e7df046d",
+    "data/rank_filters_tests_3d.npz": "1741c2b978424e93558a07d345b2a0d9bfbb33c095c123da147fca066714ab16",
+    "data/multi.fits": "5c71a83436762a52b1925f2f0d83881af7765ed50aede155af2800e54bbd5040",
+    "data/simple.fits": "cd36087fdbb909b6ba506bbff6bcd4c5f4da3a41862608fbac5e8555ef53d40f",
+    "data/palette_color.png": "c4e817035fb9f7730fe95cff1da3866dea01728efc72b6e703d78f7ab9717bdd",
+    "data/palette_gray.png": "bace7f73783bf3ab3b7fdaf701707e4fa09f0dbd0ea72cf5b12ddc73d50b02a9",
+    "data/green_palette.png": "42d49d94be8f9bc76e50639d3701ed0484258721f6b0bd7f50bb1b9274a010f0",
+    "data/truncated.jpg": "4c226038acc78012d335efba29c6119a24444a886842182b7e18db378f4a557d",
+    "data/multipage.tif": "4da0ad0d3df4807a9847247d1b5e565b50d46481f643afb5c37c14802c78130f",
+    "data/multipage_rgb.tif": "1d23b844fd38dce0e2d06f30432817cdb85e52070d8f5460a2ba58aebf34a0de",
+    "data/no_time_for_that_tiny.gif": "20abe94ba9e45f18de416c5fbef8d1f57a499600be40f9a200fae246010eefce",
+    "data/foo3x5x4indexed.png": "48a64c25c6da000ffdb5fcc34ebafe9ba3b1c9b61d7984ea7ca6dc54f9312dfa",
+    "data/gray_morph_output.npz": "49a0dae607cd8d31e134b4bfcbf0d86b13751fdce9667d8bf1ade93d435191b1",
+    "data/disk-matlab-output.npz": "8a39d5c866f6216d6a9c9166312aa4bbf4d18fab3d0dcd963c024985bde5856b",
+    "data/diamond-matlab-output.npz": "02fca68907e2b252b501dfe977eef71ae39fadaaa3702ebdc855195422ae1cc2",
+    "data/bw_text.png": "308c2b09f8975a69b212e103b18520e8cbb7a4eccfce0f757836cd371f1b9094",
+    "data/bw_text_skeleton.npy": "9ff4fc23c6a01497d7987f14e3a97cbcc39cce54b2b3b7ee33b84c1b661d0ae1",
+    "data/_blobs_3d_fiji_skeleton.tif": "e3449ad9819425959952050c147278555e5ffe1c2c4a30df29f6a1f9023e10c3",
+    "data/checker_bilevel.png": "2e207e486545874a2a3e69ba653b28fdef923157be9017559540e65d1bcb8e28",
+    "restoration/tests/astronaut_rl.npy": "3f8373e2c6182a89366e51cef6624e3625deac75fdda1079cbdad2a33322152c",
+    "restoration/tests/camera_rl.npy": "fd4f59af84dd471fbbe79ee70c1b7e68a69864c461f0db5ac587e7975363f78f",
+    "restoration/tests/camera_unsup.npy": "3de10a0b97267352b18886b25d66a967f9e1d78ada61050577d78586cab82baa",
+    "restoration/tests/camera_unsup2.npy": "29cdc60605eb528c5f014baa8564d7d1ba0bd4b3170a66522058cbe5aed0960b",
+    "restoration/tests/camera_wiener.npy": "4505ea8b0d63d03250c6d756560d615751b76dd6ffc4a95972fa260c0c84633e",
+    "registration/tests/data/OriginalX-130Y130.png": "bf24a06d99ae131c97e582ef5e1cd0c648a8dad0caab31281f3564045492811f",
+    "registration/tests/data/OriginalX130Y130.png": "7fdd4c06d504fec35ee0703bd7ed2c08830b075a74c8506bae4a70d682f5a2db",
+    "registration/tests/data/OriginalX75Y75.png": "c5cd58893c93140df02896df80b13ecf432f5c86eeaaf8fb311aec52a65c7016",
+    "registration/tests/data/TransformedX-130Y130.png": "1cda90ed69c921eb7605b73b76d141cf4ea03fb8ce3336445ca08080e40d7375",
+    "registration/tests/data/TransformedX130Y130.png": "bb10c6ae3f91a313b0ac543efdb7ca69c4b95e55674c65a88472a6c4f4692a25",
+    "registration/tests/data/TransformedX75Y75.png": "a1e9ead5f8e4a0f604271e1f9c50e89baf53f068f1d19fab2876af4938e695ea",
+    "data/brain.tiff": "bcdbaf424fbad7b1fb0f855f608c68e5a838f35affc323ff04ea17f678eef5c6",
+    "data/cells3d.tif": "afc7c7d80d38bfde09788b4064ac1e64ec14e88454ab785ebdc8dbba5ca3b222",
+    "data/palisades_of_vogt.tif": "7f205b626407e194974cead67c4d3909344cf59c42d229a349da0198183e5bd0",
+    "data/kidney.tif": "80c0799bc58b08cf6eaa53ecd202305eb42fd7bc73746cb6c5064dbeae7e8476",
+    "data/lily.tif": "395c2f0194c25b9824a8cd79266920362a0816bc9e906dd392adce2d8309af03",
+    "data/mitosis.tif": "2751ba667c4067c5d30817cff004aa06f6f6287f1cdbb5b8c9c6a500308cb456",
+    "data/skin.jpg": "8759fe080509712163453f4b17106582b8513e73b0788d80160abf840e272075",
+    "data/pivchallenge-B-B001_1.tif": "e95e09abbcecba723df283ac7d361766328abd943701a2ec2f345d4a2014da2a",
+    "data/pivchallenge-B-B001_2.tif": "4ceb5407e4e333476a0f264c14b7a3f6c0e753fcdc99ee1c4b8196e5f823805e",
+    "data/protein_transport.tif": "a8e24e8d187f33e92ee28508d5615286c850ca75374af7e74e527d290e8b06ea",
+    "data/solidification.tif": "50ef9a52c621b7c0c506ad1fe1b8ee8a158a4d7c8e50ddfce1e273a422dca3f9",
+}
+
+registry_urls = {
+    "data/brain.tiff": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/brain.tiff",
+    "data/cells3d.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/cells3d.tif",
+    "data/palisades_of_vogt.tif": "https://gitlab.com/scikit-image/data/-/raw/b2bc880f3bac23a583724befe8388dae368c52fe/in-vivo-cornea-spots.tif",
+    "data/eagle.png": "https://gitlab.com/scikit-image/data/-/raw/1e4f62ac31ba4553d176d4473a5967ad1b076d62/eagle.png",
+    "data/kidney.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/kidney-tissue-fluorescence.tif",
+    "data/lily.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/lily-of-the-valley-fluorescence.tif",
+    "data/mitosis.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/AS_09125_050116030001_D03f00d0.tif",
+    "data/rank_filters_tests_3d.npz": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/Tests_besides_Equalize_Otsu/add18_entropy/rank_filters_tests_3d.npz",
+    "data/skin.jpg": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/Normal_Epidermis_and_Dermis_with_Intradermal_Nevus_10x.JPG",
+    "data/pivchallenge-B-B001_1.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/pivchallenge/B/B001_1.tif",
+    "data/pivchallenge-B-B001_2.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/pivchallenge/B/B001_2.tif",
+    "data/protein_transport.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/NPCsingleNucleus.tif",
+    "data/solidification.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/nickel_solidification.tif",
+    "restoration/tests/astronaut_rl.npy": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/astronaut_rl.npy",
+    "data/gray_morph_output.npz": "https://gitlab.com/scikit-image/data/-/raw/806548e112bcf2b708a9a32275d335cb592480fd/Tests_besides_Equalize_Otsu/gray_morph_output.npz",
+}
+
+legacy_registry = {
+    ('data/' + filename): registry['data/' + filename] for filename in legacy_datasets
+}

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/__init__.py

@@ -0,0 +1,5 @@
+"""Drawing primitives, such as lines, circles, text, etc."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/_polygon2mask.py

@@ -0,0 +1,74 @@
+import numpy as np
+
+from . import draw
+
+
+def polygon2mask(image_shape, polygon):
+    """Create a binary mask from a polygon.
+
+    Parameters
+    ----------
+    image_shape : tuple of size 2
+        The shape of the mask.
+    polygon : (N, 2) array_like
+        The polygon coordinates of shape (N, 2) where N is
+        the number of points. The coordinates are (row, column).
+
+    Returns
+    -------
+    mask : 2-D ndarray of type 'bool'
+        The binary mask that corresponds to the input polygon.
+
+    See Also
+    --------
+    polygon:
+        Generate coordinates of pixels inside a polygon.
+
+    Notes
+    -----
+    This function does not do any border checking. Parts of the polygon that
+    are outside the coordinate space defined by `image_shape` are not drawn.
+
+    Examples
+    --------
+    >>> import skimage as ski
+    >>> image_shape = (10, 10)
+    >>> polygon = np.array([[1, 1], [2, 7], [8, 4]])
+    >>> mask = ski.draw.polygon2mask(image_shape, polygon)
+    >>> mask.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 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, 0, 0, 0, 0, 0]])
+
+    If vertices / points of the `polygon` are outside the coordinate space
+    defined by `image_shape`, only a part (or none at all) of the polygon is
+    drawn in the mask.
+
+    >>> offset = np.array([[2, -4]])
+    >>> ski.draw.polygon2mask(image_shape, polygon - offset).astype(int)
+    array([[0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 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, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    """
+    polygon = np.asarray(polygon)
+    vertex_row_coords, vertex_col_coords = polygon.T
+    fill_row_coords, fill_col_coords = draw.polygon(
+        vertex_row_coords, vertex_col_coords, image_shape
+    )
+    mask = np.zeros(image_shape, dtype=bool)
+    mask[fill_row_coords, fill_col_coords] = True
+    return mask

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/_random_shapes.py

@@ -0,0 +1,459 @@
+import math
+
+import numpy as np
+
+from .draw import polygon as draw_polygon, disk as draw_disk, ellipse as draw_ellipse
+from .._shared.utils import warn
+
+
+def _generate_rectangle_mask(point, image, shape, random):
+    """Generate a mask for a filled rectangle shape.
+
+    The height and width of the rectangle are generated randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of the rectangle.
+    image : tuple
+        The height, width and depth of the image into which the shape
+        is placed.
+    shape : tuple
+        The minimum and maximum size of the shape to fit.
+    random : `numpy.random.Generator`
+
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+
+    """
+    available_width = min(image[1] - point[1], shape[1]) - shape[0]
+    available_height = min(image[0] - point[0], shape[1]) - shape[0]
+
+    # Pick random widths and heights.
+    r = shape[0] + random.integers(max(1, available_height)) - 1
+    c = shape[0] + random.integers(max(1, available_width)) - 1
+    rectangle = draw_polygon(
+        [
+            point[0],
+            point[0] + r,
+            point[0] + r,
+            point[0],
+        ],
+        [
+            point[1],
+            point[1],
+            point[1] + c,
+            point[1] + c,
+        ],
+    )
+    label = ('rectangle', ((point[0], point[0] + r + 1), (point[1], point[1] + c + 1)))
+
+    return rectangle, label
+
+
+def _generate_circle_mask(point, image, shape, random):
+    """Generate a mask for a filled circle shape.
+
+    The radius of the circle is generated randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of the rectangle.
+    image : tuple
+        The height, width and depth of the image into which the shape is placed.
+    shape : tuple
+        The minimum and maximum size and color of the shape to fit.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+    """
+    if shape[0] == 1 or shape[1] == 1:
+        raise ValueError('size must be > 1 for circles')
+    min_radius = shape[0] // 2.0
+    max_radius = shape[1] // 2.0
+    left = point[1]
+    right = image[1] - point[1]
+    top = point[0]
+    bottom = image[0] - point[0]
+    available_radius = min(left, right, top, bottom, max_radius) - min_radius
+    if available_radius < 0:
+        raise ArithmeticError('cannot fit shape to image')
+    radius = int(min_radius + random.integers(max(1, available_radius)))
+    # TODO: think about how to deprecate this
+    # while draw_circle was deprecated in favor of draw_disk
+    # switching to a label of 'disk' here
+    # would be a breaking change for downstream libraries
+    # See discussion on naming convention here
+    # https://github.com/scikit-image/scikit-image/pull/4428
+    disk = draw_disk((point[0], point[1]), radius)
+    # Until a deprecation path is decided, always return `'circle'`
+    label = (
+        'circle',
+        (
+            (point[0] - radius + 1, point[0] + radius),
+            (point[1] - radius + 1, point[1] + radius),
+        ),
+    )
+
+    return disk, label
+
+
+def _generate_triangle_mask(point, image, shape, random):
+    """Generate a mask for a filled equilateral triangle shape.
+
+    The length of the sides of the triangle is generated randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of a up-pointing triangle.
+    image : tuple
+        The height, width and depth of the image into which the shape
+        is placed.
+    shape : tuple
+        The minimum and maximum size and color of the shape to fit.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+
+    """
+    if shape[0] == 1 or shape[1] == 1:
+        raise ValueError('dimension must be > 1 for triangles')
+    available_side = min(image[1] - point[1], point[0], shape[1]) - shape[0]
+    side = shape[0] + random.integers(max(1, available_side)) - 1
+    triangle_height = int(np.ceil(np.sqrt(3 / 4.0) * side))
+    triangle = draw_polygon(
+        [
+            point[0],
+            point[0] - triangle_height,
+            point[0],
+        ],
+        [
+            point[1],
+            point[1] + side // 2,
+            point[1] + side,
+        ],
+    )
+    label = (
+        'triangle',
+        ((point[0] - triangle_height, point[0] + 1), (point[1], point[1] + side + 1)),
+    )
+
+    return triangle, label
+
+
+def _generate_ellipse_mask(point, image, shape, random):
+    """Generate a mask for a filled ellipse shape.
+
+    The rotation, major and minor semi-axes of the ellipse are generated
+    randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of the rectangle.
+    image : tuple
+        The height, width and depth of the image into which the shape is
+        placed.
+    shape : tuple
+        The minimum and maximum size and color of the shape to fit.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+    """
+    if shape[0] == 1 or shape[1] == 1:
+        raise ValueError('size must be > 1 for ellipses')
+    min_radius = shape[0] / 2.0
+    max_radius = shape[1] / 2.0
+    left = point[1]
+    right = image[1] - point[1]
+    top = point[0]
+    bottom = image[0] - point[0]
+    available_radius = min(left, right, top, bottom, max_radius)
+    if available_radius < min_radius:
+        raise ArithmeticError('cannot fit shape to image')
+    # NOTE: very conservative because we could take into account the fact that
+    # we have 2 different radii, but this is a good first approximation.
+    # Also, we can afford to have a uniform sampling because the ellipse will
+    # be rotated.
+    r_radius = random.uniform(min_radius, available_radius + 1)
+    c_radius = random.uniform(min_radius, available_radius + 1)
+    rotation = random.uniform(-np.pi, np.pi)
+    ellipse = draw_ellipse(
+        point[0],
+        point[1],
+        r_radius,
+        c_radius,
+        shape=image[:2],
+        rotation=rotation,
+    )
+    max_radius = math.ceil(max(r_radius, c_radius))
+    min_x = np.min(ellipse[0])
+    max_x = np.max(ellipse[0]) + 1
+    min_y = np.min(ellipse[1])
+    max_y = np.max(ellipse[1]) + 1
+    label = ('ellipse', ((min_x, max_x), (min_y, max_y)))
+
+    return ellipse, label
+
+
+# Allows lookup by key as well as random selection.
+SHAPE_GENERATORS = dict(
+    rectangle=_generate_rectangle_mask,
+    circle=_generate_circle_mask,
+    triangle=_generate_triangle_mask,
+    ellipse=_generate_ellipse_mask,
+)
+SHAPE_CHOICES = list(SHAPE_GENERATORS.values())
+
+
+def _generate_random_colors(num_colors, num_channels, intensity_range, random):
+    """Generate an array of random colors.
+
+    Parameters
+    ----------
+    num_colors : int
+        Number of colors to generate.
+    num_channels : int
+        Number of elements representing color.
+    intensity_range : {tuple of tuples of ints, tuple of ints}, optional
+        The range of values to sample pixel values from. For grayscale images
+        the format is (min, max). For multichannel - ((min, max),) if the
+        ranges are equal across the channels, and
+        ((min_0, max_0), ... (min_N, max_N)) if they differ.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ValueError
+        When the `intensity_range` is not in the interval (0, 255).
+
+    Returns
+    -------
+    colors : array
+        An array of shape (num_colors, num_channels), where the values for
+        each channel are drawn from the corresponding `intensity_range`.
+
+    """
+    if num_channels == 1:
+        intensity_range = (intensity_range,)
+    elif len(intensity_range) == 1:
+        intensity_range = intensity_range * num_channels
+    colors = [random.integers(r[0], r[1] + 1, size=num_colors) for r in intensity_range]
+    return np.transpose(colors)
+
+
+def random_shapes(
+    image_shape,
+    max_shapes,
+    min_shapes=1,
+    min_size=2,
+    max_size=None,
+    num_channels=3,
+    shape=None,
+    intensity_range=None,
+    allow_overlap=False,
+    num_trials=100,
+    rng=None,
+    *,
+    channel_axis=-1,
+):
+    """Generate an image with random shapes, labeled with bounding boxes.
+
+    The image is populated with random shapes with random sizes, random
+    locations, and random colors, with or without overlap.
+
+    Shapes have random (row, col) starting coordinates and random sizes bounded
+    by `min_size` and `max_size`. It can occur that a randomly generated shape
+    will not fit the image at all. In that case, the algorithm will try again
+    with new starting coordinates a certain number of times. However, it also
+    means that some shapes may be skipped altogether. In that case, this
+    function will generate fewer shapes than requested.
+
+    Parameters
+    ----------
+    image_shape : tuple
+        The number of rows and columns of the image to generate.
+    max_shapes : int
+        The maximum number of shapes to (attempt to) fit into the shape.
+    min_shapes : int, optional
+        The minimum number of shapes to (attempt to) fit into the shape.
+    min_size : int, optional
+        The minimum dimension of each shape to fit into the image.
+    max_size : int, optional
+        The maximum dimension of each shape to fit into the image.
+    num_channels : int, optional
+        Number of channels in the generated image. If 1, generate monochrome
+        images, else color images with multiple channels. Ignored if
+        ``multichannel`` is set to False.
+    shape : {rectangle, circle, triangle, ellipse, None} str, optional
+        The name of the shape to generate or `None` to pick random ones.
+    intensity_range : {tuple of tuples of uint8, tuple of uint8}, optional
+        The range of values to sample pixel values from. For grayscale
+        images the format is (min, max). For multichannel - ((min, max),)
+        if the ranges are equal across the channels, and
+        ((min_0, max_0), ... (min_N, max_N)) if they differ. As the
+        function supports generation of uint8 arrays only, the maximum
+        range is (0, 255). If None, set to (0, 254) for each channel
+        reserving color of intensity = 255 for background.
+    allow_overlap : bool, optional
+        If `True`, allow shapes to overlap.
+    num_trials : int, optional
+        How often to attempt to fit a shape into the image before skipping it.
+    rng : {`numpy.random.Generator`, int}, optional
+        Pseudo-random number generator.
+        By default, a PCG64 generator is used (see :func:`numpy.random.default_rng`).
+        If `rng` is an int, it is used to seed the generator.
+    channel_axis : int or None, optional
+        If None, the image is assumed to be a grayscale (single channel) image.
+        Otherwise, this parameter indicates which axis of the array corresponds
+        to channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    image : uint8 array
+        An image with the fitted shapes.
+    labels : list
+        A list of labels, one per shape in the image. Each label is a
+        (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+
+    Examples
+    --------
+    >>> import skimage.draw
+    >>> image, labels = skimage.draw.random_shapes((32, 32), max_shapes=3)
+    >>> image # doctest: +SKIP
+    array([
+       [[255, 255, 255],
+        [255, 255, 255],
+        [255, 255, 255],
+        ...,
+        [255, 255, 255],
+        [255, 255, 255],
+        [255, 255, 255]]], dtype=uint8)
+    >>> labels # doctest: +SKIP
+    [('circle', ((22, 18), (25, 21))),
+     ('triangle', ((5, 6), (13, 13)))]
+    """
+    if min_size > image_shape[0] or min_size > image_shape[1]:
+        raise ValueError('Minimum dimension must be less than ncols and nrows')
+    max_size = max_size or max(image_shape[0], image_shape[1])
+
+    if channel_axis is None:
+        num_channels = 1
+
+    if intensity_range is None:
+        intensity_range = (0, 254) if num_channels == 1 else ((0, 254),)
+    else:
+        tmp = (intensity_range,) if num_channels == 1 else intensity_range
+        for intensity_pair in tmp:
+            for intensity in intensity_pair:
+                if not (0 <= intensity <= 255):
+                    msg = 'Intensity range must lie within (0, 255) interval'
+                    raise ValueError(msg)
+
+    rng = np.random.default_rng(rng)
+    user_shape = shape
+    image_shape = (image_shape[0], image_shape[1], num_channels)
+    image = np.full(image_shape, 255, dtype=np.uint8)
+    filled = np.zeros(image_shape, dtype=bool)
+    labels = []
+
+    num_shapes = rng.integers(min_shapes, max_shapes + 1)
+    colors = _generate_random_colors(num_shapes, num_channels, intensity_range, rng)
+    shape = (min_size, max_size)
+    for shape_idx in range(num_shapes):
+        if user_shape is None:
+            shape_generator = rng.choice(SHAPE_CHOICES)
+        else:
+            shape_generator = SHAPE_GENERATORS[user_shape]
+        for _ in range(num_trials):
+            # Pick start coordinates.
+            column = rng.integers(max(1, image_shape[1] - min_size))
+            row = rng.integers(max(1, image_shape[0] - min_size))
+            point = (row, column)
+            try:
+                indices, label = shape_generator(point, image_shape, shape, rng)
+            except ArithmeticError:
+                # Couldn't fit the shape, skip it.
+                indices = []
+                continue
+            # Check if there is an overlap where the mask is nonzero.
+            if allow_overlap or not filled[indices].any():
+                image[indices] = colors[shape_idx]
+                filled[indices] = True
+                labels.append(label)
+                break
+        else:
+            warn(
+                'Could not fit any shapes to image, '
+                'consider reducing the minimum dimension'
+            )
+
+    if channel_axis is None:
+        image = np.squeeze(image, axis=2)
+    else:
+        image = np.moveaxis(image, -1, channel_axis)
+
+    return image, labels

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/draw.py

@@ -0,0 +1,973 @@
+import numpy as np
+
+from .._shared._geometry import polygon_clip
+from .._shared.version_requirements import require
+from .._shared.compat import NP_COPY_IF_NEEDED
+from ._draw import (
+    _coords_inside_image,
+    _line,
+    _line_aa,
+    _polygon,
+    _ellipse_perimeter,
+    _circle_perimeter,
+    _circle_perimeter_aa,
+    _bezier_curve,
+)
+
+
+def _ellipse_in_shape(shape, center, radii, rotation=0.0):
+    """Generate coordinates of points within ellipse bounded by shape.
+
+    Parameters
+    ----------
+    shape :  iterable of ints
+        Shape of the input image.  Must be at least length 2. Only the first
+        two values are used to determine the extent of the input image.
+    center : iterable of floats
+        (row, column) position of center inside the given shape.
+    radii : iterable of floats
+        Size of two half axes (for row and column)
+    rotation : float, optional
+        Rotation of the ellipse defined by the above, in radians
+        in range (-PI, PI), in contra clockwise direction,
+        with respect to the column-axis.
+
+    Returns
+    -------
+    rows : iterable of ints
+        Row coordinates representing values within the ellipse.
+    cols : iterable of ints
+        Corresponding column coordinates representing values within the ellipse.
+    """
+    r_lim, c_lim = np.ogrid[0 : float(shape[0]), 0 : float(shape[1])]
+    r_org, c_org = center
+    r_rad, c_rad = radii
+    rotation %= np.pi
+    sin_alpha, cos_alpha = np.sin(rotation), np.cos(rotation)
+    r, c = (r_lim - r_org), (c_lim - c_org)
+    distances = ((r * cos_alpha + c * sin_alpha) / r_rad) ** 2 + (
+        (r * sin_alpha - c * cos_alpha) / c_rad
+    ) ** 2
+    return np.nonzero(distances < 1)
+
+
+def ellipse(r, c, r_radius, c_radius, shape=None, rotation=0.0):
+    """Generate coordinates of pixels within ellipse.
+
+    Parameters
+    ----------
+    r, c : double
+        Centre coordinate of ellipse.
+    r_radius, c_radius : double
+        Minor and major semi-axes. ``(r/r_radius)**2 + (c/c_radius)**2 = 1``.
+    shape : tuple, 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.
+    rotation : float, 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, cc : ndarray of int
+        Pixel coordinates of ellipse.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    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)
+
+    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)
+    """
+
+    center = np.array([r, c])
+    radii = np.array([r_radius, c_radius])
+    # allow just rotation with in range +/- 180 degree
+    rotation %= np.pi
+
+    # compute rotated radii by given rotation
+    r_radius_rot = abs(r_radius * np.cos(rotation)) + c_radius * np.sin(rotation)
+    c_radius_rot = r_radius * np.sin(rotation) + abs(c_radius * np.cos(rotation))
+    # The upper_left and lower_right corners of the smallest rectangle
+    # containing the ellipse.
+    radii_rot = np.array([r_radius_rot, c_radius_rot])
+    upper_left = np.ceil(center - radii_rot).astype(int)
+    lower_right = np.floor(center + radii_rot).astype(int)
+
+    if shape is not None:
+        # Constrain upper_left and lower_right by shape boundary.
+        upper_left = np.maximum(upper_left, np.array([0, 0]))
+        lower_right = np.minimum(lower_right, np.array(shape[:2]) - 1)
+
+    shifted_center = center - upper_left
+    bounding_shape = lower_right - upper_left + 1
+
+    rr, cc = _ellipse_in_shape(bounding_shape, shifted_center, radii, rotation)
+    rr.flags.writeable = True
+    cc.flags.writeable = True
+    rr += upper_left[0]
+    cc += upper_left[1]
+    return rr, cc
+
+
+def disk(center, radius, *, shape=None):
+    """Generate coordinates of pixels within circle.
+
+    Parameters
+    ----------
+    center : tuple
+        Center coordinate of disk.
+    radius : double
+        Radius of disk.
+    shape : tuple, optional
+        Image shape as a tuple of size 2. Determines 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.
+        The  shape might result in negative coordinates and wraparound
+        behaviour.
+
+    Returns
+    -------
+    rr, cc : ndarray of int
+        Pixel coordinates of disk.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.draw import disk
+    >>> shape = (4, 4)
+    >>> img = np.zeros(shape, dtype=np.uint8)
+    >>> rr, cc = disk((0, 0), 2, shape=shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[1, 1, 0, 0],
+           [1, 1, 0, 0],
+           [0, 0, 0, 0],
+           [0, 0, 0, 0]], dtype=uint8)
+    >>> img = np.zeros(shape, dtype=np.uint8)
+    >>> # Negative coordinates in rr and cc perform a wraparound
+    >>> rr, cc = disk((0, 0), 2, shape=None)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[1, 1, 0, 1],
+           [1, 1, 0, 1],
+           [0, 0, 0, 0],
+           [1, 1, 0, 1]], dtype=uint8)
+    >>> 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)
+    """
+    r, c = center
+    return ellipse(r, c, radius, radius, shape)
+
+
+@require("matplotlib", ">=3.3")
+def polygon_perimeter(r, c, shape=None, clip=False):
+    """Generate polygon perimeter coordinates.
+
+    Parameters
+    ----------
+    r : (N,) ndarray
+        Row coordinates of vertices of polygon.
+    c : (N,) ndarray
+        Column coordinates of vertices of polygon.
+    shape : tuple, optional
+        Image shape which is used to determine maximum extents of output pixel
+        coordinates. This is useful for polygons that exceed the image size.
+        If None, the full extents of the polygon is used.  Must be at least
+        length 2. Only the first two values are used to determine the extent of
+        the input image.
+    clip : bool, optional
+        Whether to clip the polygon to the provided shape.  If this is set
+        to True, the drawn figure will always be a closed polygon with all
+        edges visible.
+
+    Returns
+    -------
+    rr, cc : ndarray of int
+        Pixel coordinates of polygon.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Examples
+    --------
+    .. testsetup::
+        >>> import pytest; _ = pytest.importorskip('matplotlib')
+
+    >>> from skimage.draw import polygon_perimeter
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = polygon_perimeter([5, -1, 5, 10],
+    ...                            [-1, 5, 11, 5],
+    ...                            shape=img.shape, clip=True)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[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, 1, 0, 0, 0, 0, 0, 0, 0, 1],
+           [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+           [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+           [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+           [0, 1, 1, 0, 0, 0, 0, 0, 0, 1],
+           [0, 0, 0, 1, 0, 0, 0, 1, 1, 0],
+           [0, 0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8)
+
+    """
+    if clip:
+        if shape is None:
+            raise ValueError("Must specify clipping shape")
+        clip_box = np.array([0, 0, shape[0] - 1, shape[1] - 1])
+    else:
+        clip_box = np.array([np.min(r), np.min(c), np.max(r), np.max(c)])
+
+    # Do the clipping irrespective of whether clip is set.  This
+    # ensures that the returned polygon is closed and is an array.
+    r, c = polygon_clip(r, c, *clip_box)
+
+    r = np.round(r).astype(int)
+    c = np.round(c).astype(int)
+
+    # Construct line segments
+    rr, cc = [], []
+    for i in range(len(r) - 1):
+        line_r, line_c = line(r[i], c[i], r[i + 1], c[i + 1])
+        rr.extend(line_r)
+        cc.extend(line_c)
+
+    rr = np.asarray(rr)
+    cc = np.asarray(cc)
+
+    if shape is None:
+        return rr, cc
+    else:
+        return _coords_inside_image(rr, cc, shape)
+
+
+def set_color(image, coords, color, alpha=1):
+    """Set pixel color in the image at the given coordinates.
+
+    Note that this function modifies the color of the image in-place.
+    Coordinates that exceed the shape of the image will be ignored.
+
+    Parameters
+    ----------
+    image : (M, N, C) ndarray
+        Image
+    coords : tuple of ((K,) ndarray, (K,) ndarray)
+        Row and column coordinates of pixels to be colored.
+    color : (C,) ndarray
+        Color to be assigned to coordinates in the image.
+    alpha : scalar or (K,) ndarray
+        Alpha values used to blend color with image.  0 is transparent,
+        1 is opaque.
+
+    Examples
+    --------
+    >>> from skimage.draw import line, set_color
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = line(1, 1, 20, 20)
+    >>> set_color(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, 1]], dtype=uint8)
+
+    """
+    rr, cc = coords
+
+    if image.ndim == 2:
+        image = image[..., np.newaxis]
+
+    color = np.array(color, ndmin=1, copy=NP_COPY_IF_NEEDED)
+
+    if image.shape[-1] != color.shape[-1]:
+        raise ValueError(
+            f'Color shape ({color.shape[0]}) must match last '
+            'image dimension ({image.shape[-1]}).'
+        )
+
+    if np.isscalar(alpha):
+        # Can be replaced by ``full_like`` when numpy 1.8 becomes
+        # minimum dependency
+        alpha = np.ones_like(rr) * alpha
+
+    rr, cc, alpha = _coords_inside_image(rr, cc, image.shape, val=alpha)
+
+    alpha = alpha[..., np.newaxis]
+
+    color = color * alpha
+    vals = image[rr, cc] * (1 - alpha)
+
+    image[rr, cc] = vals + color
+
+
+def line(r0, c0, r1, c1):
+    """Generate line pixel coordinates.
+
+    Parameters
+    ----------
+    r0, c0 : int
+        Starting position (row, column).
+    r1, c1 : int
+        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)
+    """
+    return _line(r0, c0, r1, c1)
+
+
+def line_aa(r0, c0, r1, c1):
+    """Generate anti-aliased line pixel coordinates.
+
+    Parameters
+    ----------
+    r0, c0 : int
+        Starting position (row, column).
+    r1, c1 : int
+        End position (row, column).
+
+    Returns
+    -------
+    rr, cc, val : (N,) ndarray (int, int, float)
+        Indices of pixels (`rr`, `cc`) and intensity values (`val`).
+        ``img[rr, cc] = val``.
+
+    References
+    ----------
+    .. [1] A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012
+           http://members.chello.at/easyfilter/Bresenham.pdf
+
+    Examples
+    --------
+    >>> from skimage.draw import line_aa
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc, val = line_aa(1, 1, 8, 8)
+    >>> img[rr, cc] = val * 255
+    >>> img
+    array([[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0],
+           [  0, 255,  74,   0,   0,   0,   0,   0,   0,   0],
+           [  0,  74, 255,  74,   0,   0,   0,   0,   0,   0],
+           [  0,   0,  74, 255,  74,   0,   0,   0,   0,   0],
+           [  0,   0,   0,  74, 255,  74,   0,   0,   0,   0],
+           [  0,   0,   0,   0,  74, 255,  74,   0,   0,   0],
+           [  0,   0,   0,   0,   0,  74, 255,  74,   0,   0],
+           [  0,   0,   0,   0,   0,   0,  74, 255,  74,   0],
+           [  0,   0,   0,   0,   0,   0,   0,  74, 255,   0],
+           [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0]], dtype=uint8)
+    """
+    return _line_aa(r0, c0, r1, c1)
+
+
+def polygon(r, c, shape=None):
+    """Generate coordinates of pixels inside a polygon.
+
+    Parameters
+    ----------
+    r : (N,) array_like
+        Row coordinates of the polygon's vertices.
+    c : (N,) array_like
+        Column coordinates of the polygon's vertices.
+    shape : tuple, optional
+        Image shape which is used to determine the maximum extent of output
+        pixel coordinates. This is useful for polygons that exceed the image
+        size. If None, the full extent of the polygon 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 : ndarray of int
+        Pixel coordinates of polygon.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    See Also
+    --------
+    polygon2mask:
+        Create a binary mask from a polygon.
+
+    Notes
+    -----
+    This function ensures that `rr` and `cc` don't contain negative values.
+    Pixels of the polygon that whose coordinates are smaller 0, are not drawn.
+
+    Examples
+    --------
+    >>> import skimage as ski
+    >>> r = np.array([1, 2, 8])
+    >>> c = np.array([1, 7, 4])
+    >>> rr, cc = ski.draw.polygon(r, c)
+    >>> img = np.zeros((10, 10), dtype=int)
+    >>> 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, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 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, 0, 0, 0, 0, 0]])
+
+    If the image `shape` is defined and vertices / points of the `polygon` are
+    outside this coordinate space, only a part (or none at all) of the polygon's
+    pixels is returned. Shifting the polygon's vertices by an offset can be used
+    to move the polygon around and potentially draw an arbitrary sub-region of
+    the polygon.
+
+    >>> offset = (2, -4)
+    >>> rr, cc = ski.draw.polygon(r - offset[0], c - offset[1], shape=img.shape)
+    >>> img = np.zeros((10, 10), dtype=int)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 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, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    """
+    return _polygon(r, c, shape)
+
+
+def circle_perimeter(r, c, radius, method='bresenham', shape=None):
+    """Generate circle perimeter coordinates.
+
+    Parameters
+    ----------
+    r, c : int
+        Centre coordinate of circle.
+    radius : int
+        Radius of circle.
+    method : {'bresenham', 'andres'}, optional
+        bresenham : Bresenham method (default)
+        andres : Andres method
+    shape : tuple, 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)
+    """
+    return _circle_perimeter(r, c, radius, method, shape)
+
+
+def circle_perimeter_aa(r, c, radius, shape=None):
+    """Generate anti-aliased circle perimeter coordinates.
+
+    Parameters
+    ----------
+    r, c : int
+        Centre coordinate of circle.
+    radius : int
+        Radius of circle.
+    shape : tuple, 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)
+    """
+    return _circle_perimeter_aa(r, c, radius, shape)
+
+
+def ellipse_perimeter(r, c, r_radius, c_radius, orientation=0, shape=None):
+    """Generate ellipse perimeter coordinates.
+
+    Parameters
+    ----------
+    r, c : int
+        Centre coordinate of ellipse.
+    r_radius, c_radius : int
+        Minor and major semi-axes. ``(r/r_radius)**2 + (c/c_radius)**2 = 1``.
+    orientation : double, optional
+        Major axis orientation in clockwise direction as radians.
+    shape : tuple, 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)
+    """
+    return _ellipse_perimeter(r, c, r_radius, c_radius, orientation, shape)
+
+
+def bezier_curve(r0, c0, r1, c1, r2, c2, weight, shape=None):
+    """Generate Bezier curve coordinates.
+
+    Parameters
+    ----------
+    r0, c0 : int
+        Coordinates of the first control point.
+    r1, c1 : int
+        Coordinates of the middle control point.
+    r2, c2 : int
+        Coordinates of the last control point.
+    weight : double
+        Middle control point weight, it describes the line tension.
+    shape : tuple, 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)
+    """
+    return _bezier_curve(r0, c0, r1, c1, r2, c2, weight, shape)
+
+
+def rectangle(start, end=None, extent=None, shape=None):
+    """Generate coordinates of pixels within a rectangle.
+
+    Parameters
+    ----------
+    start : tuple
+        Origin point of the rectangle, e.g., ``([plane,] row, column)``.
+    end : tuple
+        End point of the rectangle ``([plane,] row, column)``.
+        For a 2D matrix, the slice defined by the rectangle is
+        ``[start:(end+1)]``.
+        Either `end` or `extent` must be specified.
+    extent : tuple
+        The extent (size) of the drawn rectangle.  E.g.,
+        ``([num_planes,] num_rows, num_cols)``.
+        Either `end` or `extent` must be specified.
+        A negative extent is valid, and will result in a rectangle
+        going along the opposite direction. If extent is negative, the
+        `start` point is not included.
+    shape : tuple, optional
+        Image shape used to determine the maximum bounds of the output
+        coordinates. This is useful for clipping rectangles that exceed
+        the image size. By default, no clipping is done.
+
+    Returns
+    -------
+    coords : array of int, shape (Ndim, Npoints)
+        The coordinates of all pixels in the rectangle.
+
+    Notes
+    -----
+    This function can be applied to N-dimensional images, by passing `start` and
+    `end` or `extent` as tuples of length N.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.draw import rectangle
+    >>> img = np.zeros((5, 5), dtype=np.uint8)
+    >>> start = (1, 1)
+    >>> extent = (3, 3)
+    >>> rr, cc = rectangle(start, extent=extent, shape=img.shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 0, 0, 0, 0]], dtype=uint8)
+
+
+    >>> img = np.zeros((5, 5), dtype=np.uint8)
+    >>> start = (0, 1)
+    >>> end = (3, 3)
+    >>> rr, cc = rectangle(start, end=end, shape=img.shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 0, 0, 0, 0]], dtype=uint8)
+
+    >>> import numpy as np
+    >>> from skimage.draw import rectangle
+    >>> img = np.zeros((6, 6), dtype=np.uint8)
+    >>> start = (3, 3)
+    >>>
+    >>> rr, cc = rectangle(start, extent=(2, 2))
+    >>> img[rr, cc] = 1
+    >>> rr, cc = rectangle(start, extent=(-2, 2))
+    >>> img[rr, cc] = 2
+    >>> rr, cc = rectangle(start, extent=(-2, -2))
+    >>> img[rr, cc] = 3
+    >>> rr, cc = rectangle(start, extent=(2, -2))
+    >>> img[rr, cc] = 4
+    >>> print(img)
+    [[0 0 0 0 0 0]
+     [0 3 3 2 2 0]
+     [0 3 3 2 2 0]
+     [0 4 4 1 1 0]
+     [0 4 4 1 1 0]
+     [0 0 0 0 0 0]]
+
+    """
+    tl, br = _rectangle_slice(start=start, end=end, extent=extent)
+
+    if shape is not None:
+        n_dim = len(start)
+        br = np.minimum(shape[0:n_dim], br)
+        tl = np.maximum(np.zeros_like(shape[0:n_dim]), tl)
+    coords = np.meshgrid(*[np.arange(st, en) for st, en in zip(tuple(tl), tuple(br))])
+    return coords
+
+
+@require("matplotlib", ">=3.3")
+def rectangle_perimeter(start, end=None, extent=None, shape=None, clip=False):
+    """Generate coordinates of pixels that are exactly around a rectangle.
+
+    Parameters
+    ----------
+    start : tuple
+        Origin point of the inner rectangle, e.g., ``(row, column)``.
+    end : tuple
+        End point of the inner rectangle ``(row, column)``.
+        For a 2D matrix, the slice defined by inner the rectangle is
+        ``[start:(end+1)]``.
+        Either `end` or `extent` must be specified.
+    extent : tuple
+        The extent (size) of the inner rectangle.  E.g.,
+        ``(num_rows, num_cols)``.
+        Either `end` or `extent` must be specified.
+        Negative extents are permitted. See `rectangle` to better
+        understand how they behave.
+    shape : tuple, optional
+        Image shape used to determine the maximum bounds of the output
+        coordinates. This is useful for clipping perimeters that exceed
+        the image size. By default, no clipping is done.  Must be at least
+        length 2. Only the first two values are used to determine the extent of
+        the input image.
+    clip : bool, optional
+        Whether to clip the perimeter to the provided shape. If this is set
+        to True, the drawn figure will always be a closed polygon with all
+        edges visible.
+
+    Returns
+    -------
+    coords : array of int, shape (2, Npoints)
+        The coordinates of all pixels in the rectangle.
+
+    Examples
+    --------
+    .. testsetup::
+        >>> import pytest; _ = pytest.importorskip('matplotlib')
+
+    >>> import numpy as np
+    >>> from skimage.draw import rectangle_perimeter
+    >>> img = np.zeros((5, 6), dtype=np.uint8)
+    >>> start = (2, 3)
+    >>> end = (3, 4)
+    >>> rr, cc = rectangle_perimeter(start, end=end, shape=img.shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1],
+           [0, 0, 1, 0, 0, 1],
+           [0, 0, 1, 0, 0, 1],
+           [0, 0, 1, 1, 1, 1]], dtype=uint8)
+
+    >>> img = np.zeros((5, 5), dtype=np.uint8)
+    >>> r, c = rectangle_perimeter(start, (10, 10), shape=img.shape, clip=True)
+    >>> img[r, c] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1],
+           [0, 0, 1, 0, 1],
+           [0, 0, 1, 0, 1],
+           [0, 0, 1, 1, 1]], dtype=uint8)
+
+    """
+    top_left, bottom_right = _rectangle_slice(start=start, end=end, extent=extent)
+
+    top_left -= 1
+    r = [top_left[0], top_left[0], bottom_right[0], bottom_right[0], top_left[0]]
+    c = [top_left[1], bottom_right[1], bottom_right[1], top_left[1], top_left[1]]
+    return polygon_perimeter(r, c, shape=shape, clip=clip)
+
+
+def _rectangle_slice(start, end=None, extent=None):
+    """Return the slice ``(top_left, bottom_right)`` of the rectangle.
+
+    Returns
+    -------
+    (top_left, bottom_right)
+        The slice you would need to select the region in the rectangle defined
+        by the parameters.
+        Select it like:
+
+        ``rect[top_left[0]:bottom_right[0], top_left[1]:bottom_right[1]]``
+    """
+    if end is None and extent is None:
+        raise ValueError("Either `end` or `extent` must be given.")
+    if end is not None and extent is not None:
+        raise ValueError("Cannot provide both `end` and `extent`.")
+
+    if extent is not None:
+        end = np.asarray(start) + np.asarray(extent)
+    top_left = np.minimum(start, end)
+    bottom_right = np.maximum(start, end)
+
+    top_left = np.round(top_left).astype(int)
+    bottom_right = np.round(bottom_right).astype(int)
+
+    if extent is None:
+        bottom_right += 1
+
+    return (top_left, bottom_right)

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/draw3d.py

@@ -0,0 +1,107 @@
+import numpy as np
+from scipy.special import elliprg
+
+
+def ellipsoid(a, b, c, spacing=(1.0, 1.0, 1.0), levelset=False):
+    """Generate ellipsoid for given semi-axis lengths.
+
+    The respective semi-axis lengths are given along three dimensions in
+    Cartesian coordinates. Each dimension may use a different grid spacing.
+
+    Parameters
+    ----------
+    a : float
+        Length of semi-axis along x-axis.
+    b : float
+        Length of semi-axis along y-axis.
+    c : float
+        Length of semi-axis along z-axis.
+    spacing : 3-tuple of floats
+        Grid spacing in three spatial dimensions.
+    levelset : bool
+        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
+    -------
+    ellipsoid : (M, N, 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.
+
+    """
+    if (a <= 0) or (b <= 0) or (c <= 0):
+        raise ValueError('Parameters a, b, and c must all be > 0')
+
+    offset = np.r_[1, 1, 1] * np.r_[spacing]
+
+    # Calculate limits, and ensure output volume is odd & symmetric
+    low = np.ceil(-np.r_[a, b, c] - offset)
+    high = np.floor(np.r_[a, b, c] + offset + 1)
+
+    for dim in range(3):
+        if (high[dim] - low[dim]) % 2 == 0:
+            low[dim] -= 1
+        num = np.arange(low[dim], high[dim], spacing[dim])
+        if 0 not in num:
+            low[dim] -= np.max(num[num < 0])
+
+    # Generate (anisotropic) spatial grid
+    x, y, z = np.mgrid[
+        low[0] : high[0] : spacing[0],
+        low[1] : high[1] : spacing[1],
+        low[2] : high[2] : spacing[2],
+    ]
+
+    if not levelset:
+        arr = ((x / float(a)) ** 2 + (y / float(b)) ** 2 + (z / float(c)) ** 2) <= 1
+    else:
+        arr = ((x / float(a)) ** 2 + (y / float(b)) ** 2 + (z / float(c)) ** 2) - 1
+
+    return arr
+
+
+def ellipsoid_stats(a, b, c):
+    """Calculate analytical volume and surface area of an ellipsoid.
+
+    The surface area of an ellipsoid is given by
+
+    .. math:: S=4\\pi b c R_G\\!\\left(1, \\frac{a^2}{b^2}, \\frac{a^2}{c^2}\\right)
+
+    where :math:`R_G` is Carlson's completely symmetric elliptic integral of
+    the second kind [1]_. The latter is implemented as
+    :py:func:`scipy.special.elliprg`.
+
+    Parameters
+    ----------
+    a : float
+        Length of semi-axis along x-axis.
+    b : float
+        Length of semi-axis along y-axis.
+    c : float
+        Length of semi-axis along z-axis.
+
+    Returns
+    -------
+    vol : float
+        Calculated volume of ellipsoid.
+    surf : float
+        Calculated surface area of ellipsoid.
+
+    References
+    ----------
+    .. [1] Paul Masson (2020). Surface Area of an Ellipsoid.
+           https://analyticphysics.com/Mathematical%20Methods/Surface%20Area%20of%20an%20Ellipsoid.htm
+
+    """
+    if (a <= 0) or (b <= 0) or (c <= 0):
+        raise ValueError('Parameters a, b, and c must all be > 0')
+
+    # Volume
+    vol = 4 / 3.0 * np.pi * a * b * c
+
+    # Surface area
+    surf = 3 * vol * elliprg(1 / a**2, 1 / b**2, 1 / c**2)
+
+    return vol, surf

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/draw_nd.py

@@ -0,0 +1,108 @@
+import numpy as np
+
+
+def _round_safe(coords):
+    """Round coords while ensuring successive values are less than 1 apart.
+
+    When rounding coordinates for `line_nd`, we want coordinates that are less
+    than 1 apart (always the case, by design) to remain less than one apart.
+    However, NumPy rounds values to the nearest *even* integer, so:
+
+    >>> np.round([0.5, 1.5, 2.5, 3.5, 4.5])
+    array([0., 2., 2., 4., 4.])
+
+    So, for our application, we detect whether the above case occurs, and use
+    ``np.floor`` if so. It is sufficient to detect that the first coordinate
+    falls on 0.5 and that the second coordinate is 1.0 apart, since we assume
+    by construction that the inter-point distance is less than or equal to 1
+    and that all successive points are equidistant.
+
+    Parameters
+    ----------
+    coords : 1D array of float
+        The coordinates array. We assume that all successive values are
+        equidistant (``np.all(np.diff(coords) = coords[1] - coords[0])``)
+        and that this distance is no more than 1
+        (``np.abs(coords[1] - coords[0]) <= 1``).
+
+    Returns
+    -------
+    rounded : 1D array of int
+        The array correctly rounded for an indexing operation, such that no
+        successive indices will be more than 1 apart.
+
+    Examples
+    --------
+    >>> coords0 = np.array([0.5, 1.25, 2., 2.75, 3.5])
+    >>> _round_safe(coords0)
+    array([0, 1, 2, 3, 4])
+    >>> coords1 = np.arange(0.5, 8, 1)
+    >>> coords1
+    array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5])
+    >>> _round_safe(coords1)
+    array([0, 1, 2, 3, 4, 5, 6, 7])
+    """
+    if len(coords) > 1 and coords[0] % 1 == 0.5 and coords[1] - coords[0] == 1:
+        _round_function = np.floor
+    else:
+        _round_function = np.round
+    return _round_function(coords).astype(int)
+
+
+def line_nd(start, stop, *, endpoint=False, integer=True):
+    """Draw a single-pixel thick line in n dimensions.
+
+    The line produced will be ndim-connected. That is, two subsequent
+    pixels in the line will be either direct or diagonal neighbors in
+    n dimensions.
+
+    Parameters
+    ----------
+    start : array-like, shape (N,)
+        The start coordinates of the line.
+    stop : array-like, shape (N,)
+        The end coordinates of the line.
+    endpoint : bool, optional
+        Whether to include the endpoint in the returned line. Defaults
+        to False, which allows for easy drawing of multi-point paths.
+    integer : bool, optional
+        Whether to round the coordinates to integer. If True (default),
+        the returned coordinates can be used to directly index into an
+        array. `False` could be used for e.g. vector drawing.
+
+    Returns
+    -------
+    coords : tuple of arrays
+        The coordinates of points on the line.
+
+    Examples
+    --------
+    >>> lin = line_nd((1, 1), (5, 2.5), endpoint=False)
+    >>> lin
+    (array([1, 2, 3, 4]), array([1, 1, 2, 2]))
+    >>> im = np.zeros((6, 5), dtype=int)
+    >>> im[lin] = 1
+    >>> im
+    array([[0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0],
+           [0, 1, 0, 0, 0],
+           [0, 0, 1, 0, 0],
+           [0, 0, 1, 0, 0],
+           [0, 0, 0, 0, 0]])
+    >>> line_nd([2, 1, 1], [5, 5, 2.5], endpoint=True)
+    (array([2, 3, 4, 4, 5]), array([1, 2, 3, 4, 5]), array([1, 1, 2, 2, 2]))
+    """
+    start = np.asarray(start)
+    stop = np.asarray(stop)
+    npoints = int(np.ceil(np.max(np.abs(stop - start))))
+    if endpoint:
+        npoints += 1
+
+    coords = np.linspace(start, stop, num=npoints, endpoint=endpoint).T
+    if integer:
+        for dim in range(len(start)):
+            coords[dim, :] = _round_safe(coords[dim, :])
+
+        coords = coords.astype(int)
+
+    return tuple(coords)

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/tests/test_draw.py

@@ -0,0 +1,1261 @@
+import numpy as np
+from numpy.testing import assert_array_equal, assert_equal, assert_almost_equal
+import pytest
+
+from skimage._shared.testing import run_in_parallel
+from skimage._shared._dependency_checks import has_mpl
+
+from skimage.draw import (
+    set_color,
+    line,
+    line_aa,
+    polygon,
+    polygon_perimeter,
+    disk,
+    circle_perimeter,
+    circle_perimeter_aa,
+    ellipse,
+    ellipse_perimeter,
+    _bezier_segment,
+    bezier_curve,
+    rectangle,
+    rectangle_perimeter,
+)
+from skimage.measure import regionprops
+
+
+def test_set_color():
+    img = np.zeros((10, 10))
+
+    rr, cc = line(0, 0, 0, 30)
+    set_color(img, (rr, cc), 1)
+
+    img_ = np.zeros((10, 10))
+    img_[0, :] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_set_color_with_alpha():
+    img = np.zeros((10, 10))
+
+    rr, cc, alpha = line_aa(0, 0, 0, 30)
+    set_color(img, (rr, cc), 1, alpha=alpha)
+
+    # Wrong dimensionality color
+    with pytest.raises(ValueError):
+        set_color(img, (rr, cc), (255, 0, 0), alpha=alpha)
+
+    img = np.zeros((10, 10, 3))
+
+    rr, cc, alpha = line_aa(0, 0, 0, 30)
+    set_color(img, (rr, cc), (1, 0, 0), alpha=alpha)
+
+
+@run_in_parallel()
+def test_line_horizontal():
+    img = np.zeros((10, 10))
+
+    rr, cc = line(0, 0, 0, 9)
+    img[rr, cc] = 1
+
+    img_ = np.zeros((10, 10))
+    img_[0, :] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_line_vertical():
+    img = np.zeros((10, 10))
+
+    rr, cc = line(0, 0, 9, 0)
+    img[rr, cc] = 1
+
+    img_ = np.zeros((10, 10))
+    img_[:, 0] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_line_reverse():
+    img = np.zeros((10, 10))
+
+    rr, cc = line(0, 9, 0, 0)
+    img[rr, cc] = 1
+
+    img_ = np.zeros((10, 10))
+    img_[0, :] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_line_diag():
+    img = np.zeros((5, 5))
+
+    rr, cc = line(0, 0, 4, 4)
+    img[rr, cc] = 1
+
+    img_ = np.eye(5)
+
+    assert_array_equal(img, img_)
+
+
+def test_line_aa_horizontal():
+    img = np.zeros((10, 10))
+
+    rr, cc, val = line_aa(0, 0, 0, 9)
+    set_color(img, (rr, cc), 1, alpha=val)
+
+    img_ = np.zeros((10, 10))
+    img_[0, :] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_line_aa_vertical():
+    img = np.zeros((10, 10))
+
+    rr, cc, val = line_aa(0, 0, 9, 0)
+    img[rr, cc] = val
+
+    img_ = np.zeros((10, 10))
+    img_[:, 0] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_line_aa_diagonal():
+    img = np.zeros((10, 10))
+
+    rr, cc, val = line_aa(0, 0, 9, 6)
+    img[rr, cc] = 1
+
+    # Check that each pixel belonging to line,
+    # also belongs to line_aa
+    r, c = line(0, 0, 9, 6)
+    for r_i, c_i in zip(r, c):
+        assert_equal(img[r_i, c_i], 1)
+
+
+def test_line_equal_aliasing_horizontally_vertically():
+    img0 = np.zeros((25, 25))
+    img1 = np.zeros((25, 25))
+
+    # Near-horizontal line
+    rr, cc, val = line_aa(10, 2, 12, 20)
+    img0[rr, cc] = val
+
+    # Near-vertical (transpose of prior)
+    rr, cc, val = line_aa(2, 10, 20, 12)
+    img1[rr, cc] = val
+
+    # Difference - should be zero
+    assert_array_equal(img0, img1.T)
+
+
+def test_polygon_rectangle():
+    img = np.zeros((10, 10), 'uint8')
+    poly = np.array(((1, 1), (4, 1), (4, 4), (1, 4), (1, 1)))
+
+    rr, cc = polygon(poly[:, 0], poly[:, 1])
+    img[rr, cc] = 1
+
+    img_ = np.zeros((10, 10), 'uint8')
+    img_[1:5, 1:5] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_polygon_rectangle_angular():
+    img = np.zeros((10, 10), 'uint8')
+    poly = np.array(((0, 3), (4, 7), (7, 4), (3, 0), (0, 3)))
+
+    rr, cc = polygon(poly[:, 0], poly[:, 1])
+    img[rr, cc] = 1
+
+    img_ = np.array(
+        [
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 1, 1, 0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 1, 1, 0, 0, 0, 0],
+            [1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+            [0, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
+            [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 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, 0],
+        ],
+        'uint8',
+    )
+
+    assert_array_equal(img, img_)
+
+
+def test_polygon_parallelogram():
+    img = np.zeros((10, 10), 'uint8')
+    poly = np.array(((1, 1), (5, 1), (7, 6), (3, 6), (1, 1)))
+
+    rr, cc = polygon(poly[:, 0], poly[:, 1])
+    img[rr, cc] = 1
+
+    img_ = np.array(
+        [
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+            [0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+            [0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+            [0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ],
+        'uint8',
+    )
+
+    assert_array_equal(img, img_)
+
+
+def test_polygon_exceed():
+    img = np.zeros((10, 10), 'uint8')
+    poly = np.array(((1, -1), (100, -1), (100, 100), (1, 100), (1, 1)))
+
+    rr, cc = polygon(poly[:, 0], poly[:, 1], img.shape)
+    img[rr, cc] = 1
+
+    img_ = np.zeros((10, 10))
+    img_[1:, :] = 1
+
+    assert_array_equal(img, img_)
+
+
+def test_polygon_0d_input():
+    # Bug reported in #4938: 0d input causes segfault.
+    rr, cc = polygon(0, 1)
+
+    assert rr.size == cc.size == 1
+
+
+def test_disk():
+    img = np.zeros((15, 15), 'uint8')
+
+    rr, cc = disk((7, 7), 6)
+    img[rr, cc] = 1
+
+    img_ = np.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],
+            [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
+            [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+            [0, 0, 0, 0, 1, 1, 1, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+
+    assert_array_equal(img, img_)
+
+
+def test_circle_perimeter_bresenham():
+    img = np.zeros((15, 15), 'uint8')
+    rr, cc = circle_perimeter(7, 7, 0, method='bresenham')
+    img[rr, cc] = 1
+    assert np.sum(img) == 1
+    assert img[7][7] == 1
+
+    img = np.zeros((17, 15), 'uint8')
+    rr, cc = circle_perimeter(7, 7, 7, method='bresenham')
+    img[rr, cc] = 1
+    img_ = np.array(
+        [
+            [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+
+def test_circle_perimeter_bresenham_shape():
+    img = np.zeros((15, 20), 'uint8')
+    rr, cc = circle_perimeter(7, 10, 9, method='bresenham', shape=(15, 20))
+    img[rr, cc] = 1
+    shift = 5
+    img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
+    rr, cc = circle_perimeter(7 + shift, 10, 9, method='bresenham', shape=None)
+    img_[rr, cc] = 1
+    assert_array_equal(img, img_[shift:-shift, :])
+
+
+def test_circle_perimeter_andres():
+    img = np.zeros((15, 15), 'uint8')
+    rr, cc = circle_perimeter(7, 7, 0, method='andres')
+    img[rr, cc] = 1
+    assert np.sum(img) == 1
+    assert img[7][7] == 1
+
+    img = np.zeros((17, 15), 'uint8')
+    rr, cc = circle_perimeter(7, 7, 7, method='andres')
+    img[rr, cc] = 1
+    img_ = np.array(
+        [
+            [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
+            [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
+            [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+            [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
+            [0, 0, 0, 0, 1, 1, 1, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+
+def test_circle_perimeter_aa():
+    img = np.zeros((15, 15), 'uint8')
+    rr, cc, val = circle_perimeter_aa(7, 7, 0)
+    img[rr, cc] = 1
+    assert np.sum(img) == 1
+    assert img[7][7] == 1
+
+    img = np.zeros((17, 17), 'uint8')
+    rr, cc, val = circle_perimeter_aa(8, 8, 7)
+    img[rr, cc] = val * 255
+    # fmt: off
+    img_ = np.array(
+        [[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],
+         [  0,   0,   0,   0,   0,  82, 180, 236, 255, 236, 180,  82,   0,   0,   0,   0,   0],
+         [  0,   0,   0,   0, 189, 172,  74,  18,   0,  18,  74, 172, 189,   0,   0,   0,   0],
+         [  0,   0,   0, 229,  25,   0,   0,   0,   0,   0,   0,   0,  25, 229,   0,   0,   0],
+         [  0,   0, 189,  25,   0,   0,   0,   0,   0,   0,   0,   0,   0,  25, 189,   0,   0],
+         [  0,  82, 172,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 172,  82,   0],
+         [  0, 180,  74,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  74, 180,   0],
+         [  0, 236,  18,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  18, 236,   0],
+         [  0, 255,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 255,   0],
+         [  0, 236,  18,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  18, 236,   0],
+         [  0, 180,  74,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  74, 180,   0],
+         [  0,  82, 172,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 172,  82,   0],
+         [  0,   0, 189,  25,   0,   0,   0,   0,   0,   0,   0,   0,   0,  25, 189,   0,   0],
+         [  0,   0,   0, 229,  25,   0,   0,   0,   0,   0,   0,   0,  25, 229,   0,   0,   0],
+         [  0,   0,   0,   0, 189, 172,  74,  18,   0,  18,  74, 172, 189,   0,   0,   0,   0],
+         [  0,   0,   0,   0,   0,  82, 180, 236, 255, 236, 180,  82,   0,   0,   0,   0,   0],
+         [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0]]
+    )
+    # fmt: on
+    assert_array_equal(img, img_)
+
+
+def test_circle_perimeter_aa_shape():
+    img = np.zeros((15, 20), 'uint8')
+    rr, cc, val = circle_perimeter_aa(7, 10, 9, shape=(15, 20))
+    img[rr, cc] = val * 255
+
+    shift = 5
+    img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
+    rr, cc, val = circle_perimeter_aa(7 + shift, 10, 9, shape=None)
+    img_[rr, cc] = val * 255
+    assert_array_equal(img, img_[shift:-shift, :])
+
+
+def test_ellipse_trivial():
+    img = np.zeros((2, 2), 'uint8')
+    rr, cc = ellipse(0.5, 0.5, 0.5, 0.5)
+    img[rr, cc] = 1
+    img_correct = np.array([[0, 0], [0, 0]])
+    assert_array_equal(img, img_correct)
+
+    img = np.zeros((2, 2), 'uint8')
+    rr, cc = ellipse(0.5, 0.5, 1.1, 1.1)
+    img[rr, cc] = 1
+    img_correct = np.array(
+        [
+            [1, 1],
+            [1, 1],
+        ]
+    )
+    assert_array_equal(img, img_correct)
+
+    img = np.zeros((3, 3), 'uint8')
+    rr, cc = ellipse(1, 1, 0.9, 0.9)
+    img[rr, cc] = 1
+    img_correct = np.array(
+        [
+            [0, 0, 0],
+            [0, 1, 0],
+            [0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_correct)
+
+    img = np.zeros((3, 3), 'uint8')
+    rr, cc = ellipse(1, 1, 1.1, 1.1)
+    img[rr, cc] = 1
+    img_correct = np.array(
+        [
+            [0, 1, 0],
+            [1, 1, 1],
+            [0, 1, 0],
+        ]
+    )
+    assert_array_equal(img, img_correct)
+
+    img = np.zeros((3, 3), 'uint8')
+    rr, cc = ellipse(1, 1, 1.5, 1.5)
+    img[rr, cc] = 1
+    img_correct = np.array(
+        [
+            [1, 1, 1],
+            [1, 1, 1],
+            [1, 1, 1],
+        ]
+    )
+    assert_array_equal(img, img_correct)
+
+
+def test_ellipse_generic():
+    img = np.zeros((4, 4), 'uint8')
+    rr, cc = ellipse(1.5, 1.5, 1.1, 1.7)
+    img[rr, cc] = 1
+    img_ = np.array(
+        [
+            [0, 0, 0, 0],
+            [1, 1, 1, 1],
+            [1, 1, 1, 1],
+            [0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+    img = np.zeros((5, 5), 'uint8')
+    rr, cc = ellipse(2, 2, 1.7, 1.7)
+    img[rr, cc] = 1
+    img_ = np.array(
+        [
+            [0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+    img = np.zeros((10, 10), 'uint8')
+    rr, cc = ellipse(5, 5, 3, 4)
+    img[rr, cc] = 1
+    img_ = np.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],
+            [0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
+            [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, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+    img = np.zeros((10, 10), 'uint8')
+    rr, cc = ellipse(4.5, 5, 3.5, 4)
+    img[rr, cc] = 1
+    img_ = np.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, 1, 1, 1, 1, 1, 1, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
+            [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, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+    img = np.zeros((15, 15), 'uint8')
+    rr, cc = ellipse(7, 7, 3, 7)
+    img[rr, cc] = 1
+    img_ = np.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],
+            [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],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+            [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+            [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+            [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+            [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+
+def test_ellipse_with_shape():
+    img = np.zeros((15, 15), 'uint8')
+
+    rr, cc = ellipse(7, 7, 3, 10, shape=img.shape)
+    img[rr, cc] = 1
+
+    img_ = np.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],
+            [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],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+
+    assert_array_equal(img, img_)
+
+    img = np.zeros((10, 9, 3), 'uint8')
+
+    rr, cc = ellipse(7, 7, 3, 10, shape=img.shape)
+    img[rr, cc, 0] = 1
+
+    img_ = np.zeros_like(img)
+    img_[..., 0] = np.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, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1],
+            [1, 1, 1, 1, 1, 1, 1, 1, 1],
+        ],
+    )
+
+    assert_array_equal(img, img_)
+
+
+def test_ellipse_negative():
+    rr, cc = ellipse(-3, -3, 1.7, 1.7)
+    rr_, cc_ = np.nonzero(
+        np.array(
+            [
+                [0, 0, 0, 0, 0],
+                [0, 1, 1, 1, 0],
+                [0, 1, 1, 1, 0],
+                [0, 1, 1, 1, 0],
+                [0, 0, 0, 0, 0],
+            ]
+        )
+    )
+
+    assert_array_equal(rr, rr_ - 5)
+    assert_array_equal(cc, cc_ - 5)
+
+
+def test_ellipse_rotation_symmetry():
+    img1 = np.zeros((150, 150), dtype=np.uint8)
+    img2 = np.zeros((150, 150), dtype=np.uint8)
+    for angle in range(0, 180, 15):
+        img1.fill(0)
+        rr, cc = ellipse(80, 70, 60, 40, rotation=np.deg2rad(angle))
+        img1[rr, cc] = 1
+        img2.fill(0)
+        rr, cc = ellipse(80, 70, 60, 40, rotation=np.deg2rad(angle + 180))
+        img2[rr, cc] = 1
+        assert_array_equal(img1, img2)
+
+
+def test_ellipse_rotated():
+    img = np.zeros((1000, 1200), dtype=np.uint8)
+    for rot in range(0, 180, 10):
+        img.fill(0)
+        angle = np.deg2rad(rot)
+        rr, cc = ellipse(500, 600, 200, 400, rotation=angle)
+        img[rr, cc] = 1
+        # estimate orientation of ellipse
+        angle_estim_raw = regionprops(img)[0].orientation
+        angle_estim = np.round(angle_estim_raw, 3) % (np.pi / 2)
+        assert_almost_equal(angle_estim, angle % (np.pi / 2), 2)
+
+
+def test_ellipse_perimeter_dot_zeroangle():
+    # dot, angle == 0
+    img = np.zeros((30, 15), 'uint8')
+    rr, cc = ellipse_perimeter(15, 7, 0, 0, 0)
+    img[rr, cc] = 1
+    assert np.sum(img) == 1
+    assert img[15][7] == 1
+
+
+def test_ellipse_perimeter_dot_nzeroangle():
+    # dot, angle != 0
+    img = np.zeros((30, 15), 'uint8')
+    rr, cc = ellipse_perimeter(15, 7, 0, 0, 1)
+    img[rr, cc] = 1
+    assert np.sum(img) == 1
+    assert img[15][7] == 1
+
+
+def test_ellipse_perimeter_flat_zeroangle():
+    # flat ellipse
+    img = np.zeros((20, 18), 'uint8')
+    img_ = np.zeros((20, 18), 'uint8')
+    rr, cc = ellipse_perimeter(6, 7, 0, 5, 0)
+    img[rr, cc] = 1
+    rr, cc = line(6, 2, 6, 12)
+    img_[rr, cc] = 1
+    assert_array_equal(img, img_)
+
+
+def test_ellipse_perimeter_zeroangle():
+    # angle == 0
+    img = np.zeros((30, 15), 'uint8')
+    rr, cc = ellipse_perimeter(15, 7, 14, 6, 0)
+    img[rr, cc] = 1
+    img_ = np.array(
+        [
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+
+    assert_array_equal(img, img_)
+
+
+def test_ellipse_perimeter_nzeroangle():
+    # angle != 0
+    img = np.zeros((30, 25), 'uint8')
+    rr, cc = ellipse_perimeter(15, 11, 12, 6, 1.1)
+    img[rr, cc] = 1
+    img_ = np.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, 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, 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, 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, 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],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 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, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 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, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 1, 1, 0, 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, 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, 1, 1, 1, 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, 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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_array_equal(img, img_)
+
+
+def test_ellipse_perimeter_shape():
+    img = np.zeros((15, 20), 'uint8')
+    rr, cc = ellipse_perimeter(7, 10, 9, 9, 0, shape=(15, 20))
+    img[rr, cc] = 1
+    shift = 5
+    img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
+    rr, cc = ellipse_perimeter(7 + shift, 10, 9, 9, 0, shape=None)
+    img_[rr, cc] = 1
+    assert_array_equal(img, img_[shift:-shift, :])
+
+
+def test_bezier_segment_straight():
+    image = np.zeros((200, 200), dtype=int)
+    r0, r1, r2 = 50, 150, 150
+    c0, c1, c2 = 50, 50, 150
+    rr, cc = _bezier_segment(r0, c0, r1, c1, r2, c2, 0)
+    image[rr, cc] = 1
+
+    image2 = np.zeros((200, 200), dtype=int)
+    rr, cc = line(r0, c0, r2, c2)
+    image2[rr, cc] = 1
+    assert_array_equal(image, image2)
+
+
+def test_bezier_segment_curved():
+    img = np.zeros((25, 25), 'uint8')
+    r0, c0 = 20, 20
+    r1, c1 = 20, 2
+    r2, c2 = 2, 2
+    rr, cc = _bezier_segment(r0, c0, r1, c1, r2, c2, 1)
+    img[rr, cc] = 1
+    img_ = np.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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 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, 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, 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, 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, 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, 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, 0, 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, 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, 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, 0, 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, 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, 0, 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, 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, 0, 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, 0, 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, 0, 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, 0, 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, 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, 0, 1, 1, 1, 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, 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],
+            [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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_equal(img[r0, c0], 1)
+    assert_equal(img[r2, c2], 1)
+    assert_array_equal(img, img_)
+
+
+def test_bezier_curve_straight():
+    image = np.zeros((200, 200), dtype=int)
+    r0, c0 = 50, 50
+    r1, c1 = 150, 50
+    r2, c2 = 150, 150
+    rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 0)
+    image[rr, cc] = 1
+
+    image2 = np.zeros((200, 200), dtype=int)
+    rr, cc = line(r0, c0, r2, c2)
+    image2[rr, cc] = 1
+    assert_array_equal(image, image2)
+
+
+def test_bezier_curved_weight_eq_1():
+    img = np.zeros((23, 8), 'uint8')
+    r0, c0 = 1, 1
+    r1, c1 = 11, 11
+    r2, c2 = 21, 1
+    rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 1)
+    img[rr, cc] = 1
+    assert_equal(img[r0, c0], 1)
+    assert_equal(img[r2, c2], 1)
+    img_ = np.array(
+        [
+            [0, 0, 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, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 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, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_equal(img, img_)
+
+
+def test_bezier_curved_weight_neq_1():
+    img = np.zeros((23, 10), 'uint8')
+    r0, c0 = 1, 1
+    r1, c1 = 11, 11
+    r2, c2 = 21, 1
+    rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 2)
+    img[rr, cc] = 1
+    assert_equal(img[r0, c0], 1)
+    assert_equal(img[r2, c2], 1)
+    img_ = np.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, 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, 1, 0],
+            [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, 1, 0],
+            [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, 1, 0, 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, 1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+    assert_equal(img, img_)
+
+
+def test_bezier_curve_shape():
+    img = np.zeros((15, 20), 'uint8')
+    r0, c0 = 1, 5
+    r1, c1 = 6, 11
+    r2, c2 = 1, 14
+    rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 2, shape=(15, 20))
+    img[rr, cc] = 1
+    shift = 5
+    img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
+    r0, c0 = 1 + shift, 5
+    r1, c1 = 6 + shift, 11
+    r2, c2 = 1 + shift, 14
+    rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 2, shape=None)
+    img_[rr, cc] = 1
+    assert_array_equal(img, img_[shift:-shift, :])
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_polygon_perimeter():
+    expected = np.array([[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]])
+    out = np.zeros_like(expected)
+
+    rr, cc = polygon_perimeter([0, 2, 2, 0], [0, 0, 3, 3])
+
+    out[rr, cc] = 1
+    assert_array_equal(out, expected)
+
+    out = np.zeros_like(expected)
+    rr, cc = polygon_perimeter(
+        [-1, -1, 3, 3], [-1, 4, 4, -1], shape=out.shape, clip=True
+    )
+    out[rr, cc] = 1
+    assert_array_equal(out, expected)
+
+    with pytest.raises(ValueError):
+        polygon_perimeter([0], [1], clip=True)
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_polygon_perimeter_outside_image():
+    rr, cc = polygon_perimeter([-1, -1, 3, 3], [-1, 4, 4, -1], shape=(3, 4))
+    assert_equal(len(rr), 0)
+    assert_equal(len(cc), 0)
+
+
+def test_rectangle_end():
+    expected = np.array(
+        [
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    start = (0, 1)
+    end = (3, 3)
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(start, end=end, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    # Swap start and end
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(end=start, start=end, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    # Bottom left and top right
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(start=(3, 1), end=(0, 3), shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(end=(3, 1), start=(0, 3), shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+def test_rectangle_float_input():
+    expected = np.array(
+        [
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    start = (0.2, 0.8)
+    end = (3.1, 2.9)
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(start, end=end, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    # Swap start and end
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(end=start, start=end, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    # Bottom left and top right
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(start=(3.1, 0.8), end=(0.2, 2.9), shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(end=(3.1, 0.8), start=(0.2, 2.9), shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+def test_rectangle_extent():
+    expected = np.array(
+        [
+            [0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    start = (1, 1)
+    extent = (3, 3)
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle(start, extent=extent, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    img = np.zeros((5, 5, 3), dtype=np.uint8)
+    rr, cc = rectangle(start, extent=extent, shape=img.shape)
+    img[rr, cc, 0] = 1
+    expected_2 = np.zeros_like(img)
+    expected_2[..., 0] = expected
+    assert_array_equal(img, expected_2)
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_rectangle_extent_negative():
+    # These two tests should be done together.
+    expected = np.array(
+        [
+            [0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 1, 1, 1],
+            [0, 0, 1, 2, 2, 1],
+            [0, 0, 1, 1, 1, 1],
+            [0, 0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+
+    start = (3, 5)
+    extent = (-1, -2)
+    img = np.zeros(expected.shape, dtype=np.uint8)
+    rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape)
+    img[rr, cc] = 1
+
+    rr, cc = rectangle(start, extent=extent, shape=img.shape)
+    img[rr, cc] = 2
+    assert_array_equal(img, expected)
+
+    # Ensure that rr and cc have no overlap
+    img = np.zeros(expected.shape, dtype=np.uint8)
+    rr, cc = rectangle(start, extent=extent, shape=img.shape)
+    img[rr, cc] = 2
+
+    rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_rectangle_perimiter():
+    expected = np.array(
+        [
+            [0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 1, 1, 1],
+            [0, 0, 1, 0, 0, 1],
+            [0, 0, 1, 1, 1, 1],
+            [0, 0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    start = (2, 3)
+    end = (2, 4)
+    img = np.zeros(expected.shape, dtype=np.uint8)
+    # Test that the default parameter is indeed end
+    rr, cc = rectangle_perimeter(start, end, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    # Swap start and end
+    img = np.zeros(expected.shape, dtype=np.uint8)
+    rr, cc = rectangle_perimeter(end=start, start=end, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    img = np.zeros(expected.shape, dtype=np.uint8)
+    start = (2, 3)
+    extent = (1, 2)
+    rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_rectangle_perimiter_clip_bottom_right():
+    # clip=False
+    expected = np.array(
+        [
+            [0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 1],
+            [0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((5, 5), dtype=np.uint8)
+    start = (2, 2)
+    extent = (10, 10)
+    rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape, clip=False)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    # clip=True
+    expected = np.array(
+        [
+            [0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 1],
+            [0, 1, 0, 0, 1],
+            [0, 1, 0, 0, 1],
+            [0, 1, 1, 1, 1],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape, clip=True)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_rectangle_perimiter_clip_top_left():
+    # clip=False
+    expected = np.array(
+        [
+            [0, 0, 0, 1, 0],
+            [0, 0, 0, 1, 0],
+            [0, 0, 0, 1, 0],
+            [1, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((5, 5), dtype=np.uint8)
+    start = (-5, -5)
+    end = (2, 2)
+    rr, cc = rectangle_perimeter(start, end=end, shape=img.shape, clip=False)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    # clip=True
+    expected = np.array(
+        [
+            [1, 1, 1, 1, 0],
+            [1, 0, 0, 1, 0],
+            [1, 0, 0, 1, 0],
+            [1, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle_perimeter(start, end=end, shape=img.shape, clip=True)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_rectangle_perimiter_clip_top_right():
+    expected = np.array(
+        [
+            [0, 1, 1, 1, 1],
+            [0, 1, 0, 0, 1],
+            [0, 1, 0, 0, 1],
+            [0, 1, 1, 1, 1],
+            [0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((5, 5), dtype=np.uint8)
+    start = (-10, 2)
+    end = (2, 10)
+    rr, cc = rectangle_perimeter(start, end=end, shape=img.shape, clip=True)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    expected = np.array(
+        [
+            [0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0],
+            [0, 1, 1, 1, 1],
+            [0, 0, 0, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle_perimeter(start, end=end, shape=img.shape, clip=False)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_rectangle_perimiter_clip_bottom_left():
+    expected = np.array(
+        [
+            [0, 0, 0, 0, 0],
+            [1, 1, 1, 0, 0],
+            [1, 0, 1, 0, 0],
+            [1, 0, 1, 0, 0],
+            [1, 1, 1, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((5, 5), dtype=np.uint8)
+    start = (2, -3)
+    end = (10, 1)
+    rr, cc = rectangle_perimeter(start, end=end, shape=img.shape, clip=True)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)
+
+    expected = np.array(
+        [
+            [0, 0, 0, 0, 0],
+            [1, 1, 1, 0, 0],
+            [0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0],
+        ],
+        dtype=np.uint8,
+    )
+
+    img = np.zeros((5, 5), dtype=np.uint8)
+    rr, cc = rectangle_perimeter(start, end=end, shape=img.shape, clip=False)
+    img[rr, cc] = 1
+    assert_array_equal(img, expected)

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/tests/test_draw3d.py

@@ -0,0 +1,224 @@
+import numpy as np
+from skimage._shared.testing import assert_array_equal, assert_allclose
+
+from skimage.draw import ellipsoid, ellipsoid_stats, rectangle
+from skimage._shared import testing
+
+
+def test_ellipsoid_sign_parameters1():
+    with testing.raises(ValueError):
+        ellipsoid(-1, 2, 2)
+
+
+def test_ellipsoid_sign_parameters2():
+    with testing.raises(ValueError):
+        ellipsoid(0, 2, 2)
+
+
+def test_ellipsoid_sign_parameters3():
+    with testing.raises(ValueError):
+        ellipsoid(-3, -2, 2)
+
+
+def test_ellipsoid_bool():
+    test = ellipsoid(2, 2, 2)[1:-1, 1:-1, 1:-1]
+    test_anisotropic = ellipsoid(2, 2, 4, spacing=(1.0, 1.0, 2.0))
+    test_anisotropic = test_anisotropic[1:-1, 1:-1, 1:-1]
+
+    expected = np.array(
+        [
+            [
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 1, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 0, 0, 0],
+                [0, 1, 1, 1, 0],
+                [0, 1, 1, 1, 0],
+                [0, 1, 1, 1, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 1, 0, 0],
+                [0, 1, 1, 1, 0],
+                [1, 1, 1, 1, 1],
+                [0, 1, 1, 1, 0],
+                [0, 0, 1, 0, 0],
+            ],
+            [
+                [0, 0, 0, 0, 0],
+                [0, 1, 1, 1, 0],
+                [0, 1, 1, 1, 0],
+                [0, 1, 1, 1, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 1, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+        ]
+    )
+
+    assert_array_equal(test, expected.astype(bool))
+    assert_array_equal(test_anisotropic, expected.astype(bool))
+
+
+def test_ellipsoid_levelset():
+    test = ellipsoid(2, 2, 2, levelset=True)[1:-1, 1:-1, 1:-1]
+    test_anisotropic = ellipsoid(2, 2, 4, spacing=(1.0, 1.0, 2.0), levelset=True)
+    test_anisotropic = test_anisotropic[1:-1, 1:-1, 1:-1]
+
+    expected = np.array(
+        [
+            [
+                [2.0, 1.25, 1.0, 1.25, 2.0],
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+                [1.0, 0.25, 0.0, 0.25, 1.0],
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+                [2.0, 1.25, 1.0, 1.25, 2.0],
+            ],
+            [
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+                [0.5, -0.25, -0.5, -0.25, 0.5],
+                [0.25, -0.5, -0.75, -0.5, 0.25],
+                [0.5, -0.25, -0.5, -0.25, 0.5],
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+            ],
+            [
+                [1.0, 0.25, 0.0, 0.25, 1.0],
+                [0.25, -0.5, -0.75, -0.5, 0.25],
+                [0.0, -0.75, -1.0, -0.75, 0.0],
+                [0.25, -0.5, -0.75, -0.5, 0.25],
+                [1.0, 0.25, 0.0, 0.25, 1.0],
+            ],
+            [
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+                [0.5, -0.25, -0.5, -0.25, 0.5],
+                [0.25, -0.5, -0.75, -0.5, 0.25],
+                [0.5, -0.25, -0.5, -0.25, 0.5],
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+            ],
+            [
+                [2.0, 1.25, 1.0, 1.25, 2.0],
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+                [1.0, 0.25, 0.0, 0.25, 1.0],
+                [1.25, 0.5, 0.25, 0.5, 1.25],
+                [2.0, 1.25, 1.0, 1.25, 2.0],
+            ],
+        ]
+    )
+
+    assert_allclose(test, expected)
+    assert_allclose(test_anisotropic, expected)
+
+
+def test_ellipsoid_stats():
+    # Test comparison values generated by Wolfram Alpha
+    vol, surf = ellipsoid_stats(6, 10, 16)
+    assert_allclose(1280 * np.pi, vol, atol=1e-6)
+    assert_allclose(1383.2828269179892359787, surf, atol=1e-6)
+
+    # Test when a <= b <= c does not hold
+    vol, surf = ellipsoid_stats(16, 6, 10)
+    assert_allclose(1280 * np.pi, vol, atol=1e-6)
+    assert_allclose(1383.2828269179892359787, surf, atol=1e-6)
+
+    # Larger test to ensure reliability over broad range
+    vol, surf = ellipsoid_stats(17, 27, 169)
+    assert_allclose(103428 * np.pi, vol, atol=1e-4)
+    assert_allclose(37426.253635465972897880, surf, atol=1e-6)
+
+    # For equal a, b, c values
+    vol, surf = ellipsoid_stats(10, 10, 10)
+    assert_allclose(4000 * np.pi / 3, vol, atol=1e-6)
+    assert_allclose(400 * np.pi, surf, atol=1e-6)
+
+
+def test_rect_3d_extent():
+    expected = np.array(
+        [
+            [
+                [0, 0, 1, 1, 1],
+                [0, 0, 1, 1, 1],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 1, 1, 1],
+                [0, 0, 1, 1, 1],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 1, 1, 1],
+                [0, 0, 1, 1, 1],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 1, 1, 1],
+                [0, 0, 1, 1, 1],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((4, 5, 5), dtype=np.uint8)
+    start = (0, 0, 2)
+    extent = (5, 2, 3)
+    pp, rr, cc = rectangle(start, extent=extent, shape=img.shape)
+    img[pp, rr, cc] = 1
+    assert_array_equal(img, expected)
+
+
+def test_rect_3d_end():
+    expected = np.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, 1, 1, 0],
+                [0, 0, 1, 1, 0],
+                [0, 0, 1, 1, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 1, 1, 0],
+                [0, 0, 1, 1, 0],
+                [0, 0, 1, 1, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+            [
+                [0, 0, 1, 1, 0],
+                [0, 0, 1, 1, 0],
+                [0, 0, 1, 1, 0],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ],
+        ],
+        dtype=np.uint8,
+    )
+    img = np.zeros((4, 5, 5), dtype=np.uint8)
+    start = (1, 0, 2)
+    end = (3, 2, 3)
+    pp, rr, cc = rectangle(start, end=end, shape=img.shape)
+    img[pp, rr, cc] = 1
+    assert_array_equal(img, expected)

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/tests/test_draw_nd.py

@@ -0,0 +1,18 @@
+from skimage.draw import line_nd
+from skimage._shared.testing import assert_equal
+
+
+def test_empty_line():
+    coords = line_nd((1, 1, 1), (1, 1, 1))
+    assert len(coords) == 3
+    assert all(len(c) == 0 for c in coords)
+
+
+def test_zero_line():
+    coords = line_nd((-1, -1), (2, 2))
+    assert_equal(coords, [[-1, 0, 1], [-1, 0, 1]])
+
+
+def test_no_round():
+    coords = line_nd((0.5, 0), (2.5, 0), integer=False, endpoint=True)
+    assert_equal(coords, [[0.5, 1.5, 2.5], [0, 0, 0]])

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/tests/test_polygon2mask.py

@@ -0,0 +1,15 @@
+import numpy as np
+
+from skimage import draw
+
+
+image_shape = (512, 512)
+polygon = np.array(
+    [[80, 111, 146, 234, 407, 300, 187, 45], [465, 438, 499, 380, 450, 287, 210, 167]]
+).T
+
+
+def test_polygon2mask():
+    mask = draw.polygon2mask(image_shape, polygon)
+    assert mask.shape == image_shape
+    assert mask.sum() == 57653

infer_4_47_1/lib/python3.10/site-packages/skimage/draw/tests/test_random_shapes.py

@@ -0,0 +1,178 @@
+import numpy as np
+import pytest
+
+from skimage._shared import testing
+from skimage._shared._warnings import expected_warnings
+from skimage.draw import random_shapes
+
+
+def test_generates_color_images_with_correct_shape():
+    image, _ = random_shapes((128, 128), max_shapes=10)
+    assert image.shape == (128, 128, 3)
+
+
+def test_generates_gray_images_with_correct_shape():
+    image, _ = random_shapes(
+        (4567, 123), min_shapes=3, max_shapes=20, channel_axis=None
+    )
+    assert image.shape == (4567, 123)
+
+
+def test_generates_gray_images_with_correct_shape_deprecated_multichannel():
+    image, _ = random_shapes(
+        (4567, 123), min_shapes=3, max_shapes=20, channel_axis=None
+    )
+    assert image.shape == (4567, 123)
+
+
+@pytest.mark.parametrize('channel_axis', [None, 0, 1, 2])
+def test_generated_shape_for_channel_axis(channel_axis):
+    shape = (128, 64)
+    num_channels = 5
+
+    image, _ = random_shapes(
+        shape,
+        num_channels=num_channels,
+        min_shapes=3,
+        max_shapes=10,
+        channel_axis=channel_axis,
+    )
+
+    if channel_axis is None:
+        expected_shape = shape
+    else:
+        expected_shape = tuple(np.insert(shape, channel_axis, num_channels))
+
+    assert image.shape == expected_shape
+
+
+def test_generates_correct_bounding_boxes_for_rectangles():
+    image, labels = random_shapes((128, 128), max_shapes=1, shape='rectangle', rng=42)
+
+    assert len(labels) == 1
+    label, bbox = labels[0]
+    assert label == 'rectangle', label
+
+    crop = image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]]
+
+    # The crop is filled.
+    assert (crop >= 0).all() and (crop < 255).all()
+
+    # The crop is complete.
+    image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]] = 255
+    assert (image == 255).all()
+
+
+def test_generates_correct_bounding_boxes_for_triangles():
+    image, labels = random_shapes((128, 128), max_shapes=1, shape='triangle', rng=42)
+    assert len(labels) == 1
+    label, bbox = labels[0]
+    assert label == 'triangle', label
+
+    crop = image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]]
+
+    # The crop is filled.
+    assert (crop >= 0).any() and (crop < 255).any()
+
+    # The crop is complete.
+    image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]] = 255
+    assert (image == 255).all()
+
+
+def test_generates_correct_bounding_boxes_for_circles():
+    image, labels = random_shapes(
+        (43, 44), max_shapes=1, min_size=20, max_size=20, shape='circle', rng=42
+    )
+    assert len(labels) == 1
+    label, bbox = labels[0]
+    assert label == 'circle', label
+
+    crop = image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]]
+
+    # The crop is filled.
+    assert (crop >= 0).any() and (crop < 255).any()
+
+    # The crop is complete.
+    image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]] = 255
+    assert (image == 255).all()
+
+
+def test_generates_correct_bounding_boxes_for_ellipses():
+    image, labels = random_shapes(
+        (43, 44), max_shapes=1, min_size=20, max_size=20, shape='ellipse', rng=42
+    )
+    assert len(labels) == 1
+    label, bbox = labels[0]
+    assert label == 'ellipse', label
+
+    crop = image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]]
+
+    # The crop is filled.
+    assert (crop >= 0).any() and (crop < 255).any()
+
+    # The crop is complete.
+    image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]] = 255
+    assert (image == 255).all()
+
+
+def test_generate_circle_throws_when_size_too_small():
+    with testing.raises(ValueError):
+        random_shapes((64, 128), max_shapes=1, min_size=1, max_size=1, shape='circle')
+
+
+def test_generate_ellipse_throws_when_size_too_small():
+    with testing.raises(ValueError):
+        random_shapes((64, 128), max_shapes=1, min_size=1, max_size=1, shape='ellipse')
+
+
+def test_generate_triangle_throws_when_size_too_small():
+    with testing.raises(ValueError):
+        random_shapes((128, 64), max_shapes=1, min_size=1, max_size=1, shape='triangle')
+
+
+def test_can_generate_one_by_one_rectangle():
+    image, labels = random_shapes(
+        (50, 128), max_shapes=1, min_size=1, max_size=1, shape='rectangle'
+    )
+    assert len(labels) == 1
+    _, bbox = labels[0]
+    crop = image[bbox[0][0] : bbox[0][1], bbox[1][0] : bbox[1][1]]
+
+    # rgb
+    assert np.shape(crop) == (1, 1, 3) and np.any(crop >= 1) and np.any(crop < 255)
+
+
+def test_throws_when_intensity_range_out_of_range():
+    with testing.raises(ValueError):
+        random_shapes(
+            (1000, 1234), max_shapes=1, channel_axis=None, intensity_range=(0, 256)
+        )
+    with testing.raises(ValueError):
+        random_shapes((2, 2), max_shapes=1, intensity_range=((-1, 255),))
+
+
+def test_returns_empty_labels_and_white_image_when_cannot_fit_shape():
+    # The circle will never fit this.
+    with expected_warnings(['Could not fit']):
+        image, labels = random_shapes(
+            (10000, 10000), max_shapes=1, min_size=10000, shape='circle'
+        )
+    assert len(labels) == 0
+    assert (image == 255).all()
+
+
+def test_random_shapes_is_reproducible_with_seed():
+    random_seed = 42
+    labels = []
+    for _ in range(5):
+        _, label = random_shapes((128, 128), max_shapes=5, rng=random_seed)
+        labels.append(label)
+    assert all(other == labels[0] for other in labels[1:])
+
+
+def test_generates_white_image_when_intensity_range_255():
+    image, labels = random_shapes(
+        (128, 128), max_shapes=3, intensity_range=((255, 255),), rng=42
+    )
+    assert len(labels) > 0
+    assert (image == 255).all()

infer_4_47_1/lib/python3.10/site-packages/skimage/feature/_texture.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91efbe3cf5cda615657a302daea1bbeb1ed270401c795fa85dd7871656f6dcdc
+size 398936

infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/_convex_hull.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd110bbb9d540f7168ffe264050861f0629facfed8ef40e52ff57e2e8c0db7ef
+size 236312

infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/_grayreconstruct.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fe6f109ed45a049f330ef30144c19422287b6e2bf209150e70a58d4f90cb6c1
+size 294480

infer_4_47_1/lib/python3.10/site-packages/skimage/morphology/ball_decompositions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f9eb51f361fd7d7d22d342dec7bb98178a21aa9c944507f25898b8ca213e54d
+size 431

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/__init__.py

@@ -0,0 +1,5 @@
+"""Image registration algorithms, e.g., optical flow or phase cross correlation."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/__init__.pyi

@@ -0,0 +1,8 @@
+# Explicitly setting `__all__` is necessary for type inference engines
+# to know which symbols are exported. See
+# https://peps.python.org/pep-0484/#stub-files
+
+__all__ = ['optical_flow_ilk', 'optical_flow_tvl1', 'phase_cross_correlation']
+
+from ._optical_flow import optical_flow_tvl1, optical_flow_ilk
+from ._phase_cross_correlation import phase_cross_correlation

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/_masked_phase_cross_correlation.py

@@ -0,0 +1,306 @@
+"""
+Implementation of the masked normalized cross-correlation.
+
+Based on the following publication:
+D. Padfield. Masked object registration in the Fourier domain.
+IEEE Transactions on Image Processing (2012)
+
+and the author's original MATLAB implementation, available on this website:
+http://www.dirkpadfield.com/
+"""
+
+from functools import partial
+
+import numpy as np
+import scipy.fft as fftmodule
+from scipy.fft import next_fast_len
+
+from .._shared.utils import _supported_float_type
+
+
+def _masked_phase_cross_correlation(
+    reference_image, moving_image, reference_mask, moving_mask=None, overlap_ratio=0.3
+):
+    """Masked image translation registration by masked normalized
+    cross-correlation.
+
+    Parameters
+    ----------
+    reference_image : ndarray
+        Reference image.
+    moving_image : ndarray
+        Image to register. Must be same dimensionality as ``reference_image``,
+        but not necessarily the same size.
+    reference_mask : ndarray
+        Boolean mask for ``reference_image``. The mask should evaluate
+        to ``True`` (or 1) on valid pixels. ``reference_mask`` should
+        have the same shape as ``reference_image``.
+    moving_mask : ndarray or None, optional
+        Boolean mask for ``moving_image``. The mask should evaluate to ``True``
+        (or 1) on valid pixels. ``moving_mask`` should have the same shape
+        as ``moving_image``. If ``None``, ``reference_mask`` will be used.
+    overlap_ratio : float, optional
+        Minimum allowed overlap ratio between images. The correlation for
+        translations corresponding with an overlap ratio lower than this
+        threshold will be ignored. A lower `overlap_ratio` leads to smaller
+        maximum translation, while a higher `overlap_ratio` leads to greater
+        robustness against spurious matches due to small overlap between
+        masked images.
+
+    Returns
+    -------
+    shifts : ndarray
+        Shift vector (in pixels) required to register ``moving_image``
+        with ``reference_image``. Axis ordering is consistent with numpy.
+
+    References
+    ----------
+    .. [1] Dirk Padfield. Masked Object Registration in the Fourier Domain.
+           IEEE Transactions on Image Processing, vol. 21(5),
+           pp. 2706-2718 (2012). :DOI:`10.1109/TIP.2011.2181402`
+    .. [2] D. Padfield. "Masked FFT registration". In Proc. Computer Vision and
+           Pattern Recognition, pp. 2918-2925 (2010).
+           :DOI:`10.1109/CVPR.2010.5540032`
+
+    """
+    if moving_mask is None:
+        if reference_image.shape != moving_image.shape:
+            raise ValueError(
+                "Input images have different shapes, moving_mask must "
+                "be explicitly set."
+            )
+        moving_mask = reference_mask.astype(bool)
+
+    # We need masks to be of the same size as their respective images
+    for im, mask in [(reference_image, reference_mask), (moving_image, moving_mask)]:
+        if im.shape != mask.shape:
+            raise ValueError("Image sizes must match their respective mask sizes.")
+
+    xcorr = cross_correlate_masked(
+        moving_image,
+        reference_image,
+        moving_mask,
+        reference_mask,
+        axes=tuple(range(moving_image.ndim)),
+        mode='full',
+        overlap_ratio=overlap_ratio,
+    )
+
+    # Generalize to the average of multiple equal maxima
+    maxima = np.stack(np.nonzero(xcorr == xcorr.max()), axis=1)
+    center = np.mean(maxima, axis=0)
+    shifts = center - np.array(reference_image.shape) + 1
+
+    # The mismatch in size will impact the center location of the
+    # cross-correlation
+    size_mismatch = np.array(moving_image.shape) - np.array(reference_image.shape)
+
+    return -shifts + (size_mismatch / 2)
+
+
+def cross_correlate_masked(
+    arr1, arr2, m1, m2, mode='full', axes=(-2, -1), overlap_ratio=0.3
+):
+    """
+    Masked normalized cross-correlation between arrays.
+
+    Parameters
+    ----------
+    arr1 : ndarray
+        First array.
+    arr2 : ndarray
+        Seconds array. The dimensions of `arr2` along axes that are not
+        transformed should be equal to that of `arr1`.
+    m1 : ndarray
+        Mask of `arr1`. The mask should evaluate to `True`
+        (or 1) on valid pixels. `m1` should have the same shape as `arr1`.
+    m2 : ndarray
+        Mask of `arr2`. The mask should evaluate to `True`
+        (or 1) on valid pixels. `m2` should have the same shape as `arr2`.
+    mode : {'full', 'same'}, optional
+        'full':
+            This returns the convolution at each point of overlap. At
+            the end-points of the convolution, the signals do not overlap
+            completely, and boundary effects may be seen.
+        'same':
+            The output is the same size as `arr1`, centered with respect
+            to the `‘full’` output. Boundary effects are less prominent.
+    axes : tuple of ints, optional
+        Axes along which to compute the cross-correlation.
+    overlap_ratio : float, optional
+        Minimum allowed overlap ratio between images. The correlation for
+        translations corresponding with an overlap ratio lower than this
+        threshold will be ignored. A lower `overlap_ratio` leads to smaller
+        maximum translation, while a higher `overlap_ratio` leads to greater
+        robustness against spurious matches due to small overlap between
+        masked images.
+
+    Returns
+    -------
+    out : ndarray
+        Masked normalized cross-correlation.
+
+    Raises
+    ------
+    ValueError : if correlation `mode` is not valid, or array dimensions along
+        non-transformation axes are not equal.
+
+    References
+    ----------
+    .. [1] Dirk Padfield. Masked Object Registration in the Fourier Domain.
+           IEEE Transactions on Image Processing, vol. 21(5),
+           pp. 2706-2718 (2012). :DOI:`10.1109/TIP.2011.2181402`
+    .. [2] D. Padfield. "Masked FFT registration". In Proc. Computer Vision and
+           Pattern Recognition, pp. 2918-2925 (2010).
+           :DOI:`10.1109/CVPR.2010.5540032`
+    """
+    if mode not in {'full', 'same'}:
+        raise ValueError(f"Correlation mode '{mode}' is not valid.")
+
+    fixed_image = np.asarray(arr1)
+    moving_image = np.asarray(arr2)
+    float_dtype = _supported_float_type((fixed_image.dtype, moving_image.dtype))
+    if float_dtype.kind == 'c':
+        raise ValueError("complex-valued arr1, arr2 are not supported")
+
+    fixed_image = fixed_image.astype(float_dtype)
+    fixed_mask = np.array(m1, dtype=bool)
+    moving_image = moving_image.astype(float_dtype)
+    moving_mask = np.array(m2, dtype=bool)
+    eps = np.finfo(float_dtype).eps
+
+    # Array dimensions along non-transformation axes should be equal.
+    all_axes = set(range(fixed_image.ndim))
+    for axis in all_axes - set(axes):
+        if fixed_image.shape[axis] != moving_image.shape[axis]:
+            raise ValueError(
+                f'Array shapes along non-transformation axes should be '
+                f'equal, but dimensions along axis {axis} are not.'
+            )
+
+    # Determine final size along transformation axes
+    # Note that it might be faster to compute Fourier transform in a slightly
+    # larger shape (`fast_shape`). Then, after all fourier transforms are done,
+    # we slice back to`final_shape` using `final_slice`.
+    final_shape = list(arr1.shape)
+    for axis in axes:
+        final_shape[axis] = fixed_image.shape[axis] + moving_image.shape[axis] - 1
+    final_shape = tuple(final_shape)
+    final_slice = tuple([slice(0, int(sz)) for sz in final_shape])
+
+    # Extent transform axes to the next fast length (i.e. multiple of 3, 5, or
+    # 7)
+    fast_shape = tuple([next_fast_len(final_shape[ax]) for ax in axes])
+
+    # We use the new scipy.fft because they allow leaving the transform axes
+    # unchanged which was not possible with scipy.fftpack's
+    # fftn/ifftn in older versions of SciPy.
+    # E.g. arr shape (2, 3, 7), transform along axes (0, 1) with shape (4, 4)
+    # results in arr_fft shape (4, 4, 7)
+    fft = partial(fftmodule.fftn, s=fast_shape, axes=axes)
+    _ifft = partial(fftmodule.ifftn, s=fast_shape, axes=axes)
+
+    def ifft(x):
+        return _ifft(x).real
+
+    fixed_image[np.logical_not(fixed_mask)] = 0.0
+    moving_image[np.logical_not(moving_mask)] = 0.0
+
+    # N-dimensional analog to rotation by 180deg is flip over all relevant axes.
+    # See [1] for discussion.
+    rotated_moving_image = _flip(moving_image, axes=axes)
+    rotated_moving_mask = _flip(moving_mask, axes=axes)
+
+    fixed_fft = fft(fixed_image)
+    rotated_moving_fft = fft(rotated_moving_image)
+    fixed_mask_fft = fft(fixed_mask.astype(float_dtype))
+    rotated_moving_mask_fft = fft(rotated_moving_mask.astype(float_dtype))
+
+    # Calculate overlap of masks at every point in the convolution.
+    # Locations with high overlap should not be taken into account.
+    number_overlap_masked_px = ifft(rotated_moving_mask_fft * fixed_mask_fft)
+    number_overlap_masked_px[:] = np.round(number_overlap_masked_px)
+    number_overlap_masked_px[:] = np.fmax(number_overlap_masked_px, eps)
+    masked_correlated_fixed_fft = ifft(rotated_moving_mask_fft * fixed_fft)
+    masked_correlated_rotated_moving_fft = ifft(fixed_mask_fft * rotated_moving_fft)
+
+    numerator = ifft(rotated_moving_fft * fixed_fft)
+    numerator -= (
+        masked_correlated_fixed_fft
+        * masked_correlated_rotated_moving_fft
+        / number_overlap_masked_px
+    )
+
+    fixed_squared_fft = fft(np.square(fixed_image))
+    fixed_denom = ifft(rotated_moving_mask_fft * fixed_squared_fft)
+    fixed_denom -= np.square(masked_correlated_fixed_fft) / number_overlap_masked_px
+    fixed_denom[:] = np.fmax(fixed_denom, 0.0)
+
+    rotated_moving_squared_fft = fft(np.square(rotated_moving_image))
+    moving_denom = ifft(fixed_mask_fft * rotated_moving_squared_fft)
+    moving_denom -= (
+        np.square(masked_correlated_rotated_moving_fft) / number_overlap_masked_px
+    )
+    moving_denom[:] = np.fmax(moving_denom, 0.0)
+
+    denom = np.sqrt(fixed_denom * moving_denom)
+
+    # Slice back to expected convolution shape.
+    numerator = numerator[final_slice]
+    denom = denom[final_slice]
+    number_overlap_masked_px = number_overlap_masked_px[final_slice]
+
+    if mode == 'same':
+        _centering = partial(_centered, newshape=fixed_image.shape, axes=axes)
+        denom = _centering(denom)
+        numerator = _centering(numerator)
+        number_overlap_masked_px = _centering(number_overlap_masked_px)
+
+    # Pixels where `denom` is very small will introduce large
+    # numbers after division. To get around this problem,
+    # we zero-out problematic pixels.
+    tol = 1e3 * eps * np.max(np.abs(denom), axis=axes, keepdims=True)
+    nonzero_indices = denom > tol
+
+    # explicitly set out dtype for compatibility with SciPy < 1.4, where
+    # fftmodule will be numpy.fft which always uses float64 dtype.
+    out = np.zeros_like(denom, dtype=float_dtype)
+    out[nonzero_indices] = numerator[nonzero_indices] / denom[nonzero_indices]
+    np.clip(out, a_min=-1, a_max=1, out=out)
+
+    # Apply overlap ratio threshold
+    number_px_threshold = overlap_ratio * np.max(
+        number_overlap_masked_px, axis=axes, keepdims=True
+    )
+    out[number_overlap_masked_px < number_px_threshold] = 0.0
+
+    return out
+
+
+def _centered(arr, newshape, axes):
+    """Return the center `newshape` portion of `arr`, leaving axes not
+    in `axes` untouched."""
+    newshape = np.asarray(newshape)
+    currshape = np.array(arr.shape)
+
+    slices = [slice(None, None)] * arr.ndim
+
+    for ax in axes:
+        startind = (currshape[ax] - newshape[ax]) // 2
+        endind = startind + newshape[ax]
+        slices[ax] = slice(startind, endind)
+
+    return arr[tuple(slices)]
+
+
+def _flip(arr, axes=None):
+    """Reverse array over many axes. Generalization of arr[::-1] for many
+    dimensions. If `axes` is `None`, flip along all axes."""
+    if axes is None:
+        reverse = [slice(None, None, -1)] * arr.ndim
+    else:
+        reverse = [slice(None, None, None)] * arr.ndim
+        for axis in axes:
+            reverse[axis] = slice(None, None, -1)
+
+    return arr[tuple(reverse)]

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/_optical_flow.py

@@ -0,0 +1,429 @@
+"""TV-L1 optical flow algorithm implementation."""
+
+from functools import partial
+from itertools import combinations_with_replacement
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from .._shared.filters import gaussian as gaussian_filter
+from .._shared.utils import _supported_float_type
+from ..transform import warp
+from ._optical_flow_utils import _coarse_to_fine, _get_warp_points
+
+
+def _tvl1(
+    reference_image,
+    moving_image,
+    flow0,
+    attachment,
+    tightness,
+    num_warp,
+    num_iter,
+    tol,
+    prefilter,
+):
+    """TV-L1 solver for optical flow estimation.
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    flow0 : ndarray, shape (image0.ndim, M, N[, P[, ...]])
+        Initialization for the vector field.
+    attachment : float
+        Attachment parameter. The smaller this parameter is,
+        the smoother is the solutions.
+    tightness : float
+        Tightness parameter. It should have a small value in order to
+        maintain attachment and regularization parts in
+        correspondence.
+    num_warp : int
+        Number of times moving_image is warped.
+    num_iter : int
+        Number of fixed point iteration.
+    tol : float
+        Tolerance used as stopping criterion based on the L² distance
+        between two consecutive values of (u, v).
+    prefilter : bool
+        Whether to prefilter the estimated optical flow before each
+        image warp.
+
+    Returns
+    -------
+    flow : ndarray, shape (image0.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    """
+
+    dtype = reference_image.dtype
+    grid = np.meshgrid(
+        *[np.arange(n, dtype=dtype) for n in reference_image.shape],
+        indexing='ij',
+        sparse=True,
+    )
+
+    # dt corresponds to tau in [3]_, i.e. the time step
+    dt = 0.5 / reference_image.ndim
+    reg_num_iter = 2
+    f0 = attachment * tightness
+    f1 = dt / tightness
+    tol *= reference_image.size
+
+    flow_current = flow_previous = flow0
+
+    g = np.zeros((reference_image.ndim,) + reference_image.shape, dtype=dtype)
+    proj = np.zeros(
+        (
+            reference_image.ndim,
+            reference_image.ndim,
+        )
+        + reference_image.shape,
+        dtype=dtype,
+    )
+
+    s_g = [
+        slice(None),
+    ] * g.ndim
+    s_p = [
+        slice(None),
+    ] * proj.ndim
+    s_d = [
+        slice(None),
+    ] * (proj.ndim - 2)
+
+    for _ in range(num_warp):
+        if prefilter:
+            flow_current = ndi.median_filter(
+                flow_current, [1] + reference_image.ndim * [3]
+            )
+
+        image1_warp = warp(
+            moving_image, _get_warp_points(grid, flow_current), mode='edge'
+        )
+        grad = np.array(np.gradient(image1_warp))
+        NI = (grad * grad).sum(0)
+        NI[NI == 0] = 1
+
+        rho_0 = image1_warp - reference_image - (grad * flow_current).sum(0)
+
+        for _ in range(num_iter):
+            # Data term
+
+            rho = rho_0 + (grad * flow_current).sum(0)
+
+            idx = abs(rho) <= f0 * NI
+
+            flow_auxiliary = flow_current
+
+            flow_auxiliary[:, idx] -= rho[idx] * grad[:, idx] / NI[idx]
+
+            idx = ~idx
+            srho = f0 * np.sign(rho[idx])
+            flow_auxiliary[:, idx] -= srho * grad[:, idx]
+
+            # Regularization term
+            flow_current = flow_auxiliary.copy()
+
+            for idx in range(reference_image.ndim):
+                s_p[0] = idx
+                for _ in range(reg_num_iter):
+                    for ax in range(reference_image.ndim):
+                        s_g[0] = ax
+                        s_g[ax + 1] = slice(0, -1)
+                        g[tuple(s_g)] = np.diff(flow_current[idx], axis=ax)
+                        s_g[ax + 1] = slice(None)
+
+                    norm = np.sqrt((g**2).sum(0))[np.newaxis, ...]
+                    norm *= f1
+                    norm += 1.0
+                    proj[idx] -= dt * g
+                    proj[idx] /= norm
+
+                    # d will be the (negative) divergence of proj[idx]
+                    d = -proj[idx].sum(0)
+                    for ax in range(reference_image.ndim):
+                        s_p[1] = ax
+                        s_p[ax + 2] = slice(0, -1)
+                        s_d[ax] = slice(1, None)
+                        d[tuple(s_d)] += proj[tuple(s_p)]
+                        s_p[ax + 2] = slice(None)
+                        s_d[ax] = slice(None)
+
+                    flow_current[idx] = flow_auxiliary[idx] + d
+
+        flow_previous -= flow_current  # The difference as stopping criteria
+        if (flow_previous * flow_previous).sum() < tol:
+            break
+
+        flow_previous = flow_current
+
+    return flow_current
+
+
+def optical_flow_tvl1(
+    reference_image,
+    moving_image,
+    *,
+    attachment=15,
+    tightness=0.3,
+    num_warp=5,
+    num_iter=10,
+    tol=1e-4,
+    prefilter=False,
+    dtype=np.float32,
+):
+    r"""Coarse to fine optical flow estimator.
+
+    The TV-L1 solver is applied at each level of the image
+    pyramid. TV-L1 is a popular algorithm for optical flow estimation
+    introduced by Zack et al. [1]_, improved in [2]_ and detailed in [3]_.
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    attachment : float, optional
+        Attachment parameter (:math:`\lambda` in [1]_). The smaller
+        this parameter is, the smoother the returned result will be.
+    tightness : float, optional
+        Tightness parameter (:math:`\theta` in [1]_). It should have
+        a small value in order to maintain attachment and
+        regularization parts in correspondence.
+    num_warp : int, optional
+        Number of times moving_image is warped.
+    num_iter : int, optional
+        Number of fixed point iteration.
+    tol : float, optional
+        Tolerance used as stopping criterion based on the L² distance
+        between two consecutive values of (u, v).
+    prefilter : bool, optional
+        Whether to prefilter the estimated optical flow before each
+        image warp. When True, a median filter with window size 3
+        along each axis is applied. This helps to remove potential
+        outliers.
+    dtype : dtype, optional
+        Output data type: must be floating point. Single precision
+        provides good results and saves memory usage and computation
+        time compared to double precision.
+
+    Returns
+    -------
+    flow : ndarray, shape (image0.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    Notes
+    -----
+    Color images are not supported.
+
+    References
+    ----------
+    .. [1] Zach, C., Pock, T., & Bischof, H. (2007, September). A
+       duality based approach for realtime TV-L 1 optical flow. In Joint
+       pattern recognition symposium (pp. 214-223). Springer, Berlin,
+       Heidelberg. :DOI:`10.1007/978-3-540-74936-3_22`
+    .. [2] Wedel, A., Pock, T., Zach, C., Bischof, H., & Cremers,
+       D. (2009). An improved algorithm for TV-L 1 optical flow. In
+       Statistical and geometrical approaches to visual motion analysis
+       (pp. 23-45). Springer, Berlin, Heidelberg.
+       :DOI:`10.1007/978-3-642-03061-1_2`
+    .. [3] Pérez, J. S., Meinhardt-Llopis, E., & Facciolo,
+       G. (2013). TV-L1 optical flow estimation. Image Processing On
+       Line, 2013, 137-150. :DOI:`10.5201/ipol.2013.26`
+
+    Examples
+    --------
+    >>> from skimage.color import rgb2gray
+    >>> from skimage.data import stereo_motorcycle
+    >>> from skimage.registration import optical_flow_tvl1
+    >>> image0, image1, disp = stereo_motorcycle()
+    >>> # --- Convert the images to gray level: color is not supported.
+    >>> image0 = rgb2gray(image0)
+    >>> image1 = rgb2gray(image1)
+    >>> flow = optical_flow_tvl1(image1, image0)
+
+    """
+
+    solver = partial(
+        _tvl1,
+        attachment=attachment,
+        tightness=tightness,
+        num_warp=num_warp,
+        num_iter=num_iter,
+        tol=tol,
+        prefilter=prefilter,
+    )
+
+    if np.dtype(dtype) != _supported_float_type(dtype):
+        msg = f"dtype={dtype} is not supported. Try 'float32' or 'float64.'"
+        raise ValueError(msg)
+
+    return _coarse_to_fine(reference_image, moving_image, solver, dtype=dtype)
+
+
+def _ilk(reference_image, moving_image, flow0, radius, num_warp, gaussian, prefilter):
+    """Iterative Lucas-Kanade (iLK) solver for optical flow estimation.
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    flow0 : ndarray, shape (reference_image.ndim, M, N[, P[, ...]])
+        Initialization for the vector field.
+    radius : int
+        Radius of the window considered around each pixel.
+    num_warp : int
+        Number of times moving_image is warped.
+    gaussian : bool
+        if True, a gaussian kernel is used for the local
+        integration. Otherwise, a uniform kernel is used.
+    prefilter : bool
+        Whether to prefilter the estimated optical flow before each
+        image warp. This helps to remove potential outliers.
+
+    Returns
+    -------
+    flow : ndarray, shape (reference_image.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    """
+    dtype = reference_image.dtype
+    ndim = reference_image.ndim
+    size = 2 * radius + 1
+
+    if gaussian:
+        sigma = ndim * (size / 4,)
+        filter_func = partial(gaussian_filter, sigma=sigma, mode='mirror')
+    else:
+        filter_func = partial(ndi.uniform_filter, size=ndim * (size,), mode='mirror')
+
+    flow = flow0
+    # For each pixel location (i, j), the optical flow X = flow[:, i, j]
+    # is the solution of the ndim x ndim linear system
+    # A[i, j] * X = b[i, j]
+    A = np.zeros(reference_image.shape + (ndim, ndim), dtype=dtype)
+    b = np.zeros(reference_image.shape + (ndim, 1), dtype=dtype)
+
+    grid = np.meshgrid(
+        *[np.arange(n, dtype=dtype) for n in reference_image.shape],
+        indexing='ij',
+        sparse=True,
+    )
+
+    for _ in range(num_warp):
+        if prefilter:
+            flow = ndi.median_filter(flow, (1,) + ndim * (3,))
+
+        moving_image_warp = warp(
+            moving_image, _get_warp_points(grid, flow), mode='edge'
+        )
+        grad = np.stack(np.gradient(moving_image_warp), axis=0)
+        error_image = (grad * flow).sum(axis=0) + reference_image - moving_image_warp
+
+        # Local linear systems creation
+        for i, j in combinations_with_replacement(range(ndim), 2):
+            A[..., i, j] = A[..., j, i] = filter_func(grad[i] * grad[j])
+
+        for i in range(ndim):
+            b[..., i, 0] = filter_func(grad[i] * error_image)
+
+        # Don't consider badly conditioned linear systems
+        idx = abs(np.linalg.det(A)) < 1e-14
+        A[idx] = np.eye(ndim, dtype=dtype)
+        b[idx] = 0
+
+        # Solve the local linear systems
+        flow = np.moveaxis(np.linalg.solve(A, b)[..., 0], ndim, 0)
+
+    return flow
+
+
+def optical_flow_ilk(
+    reference_image,
+    moving_image,
+    *,
+    radius=7,
+    num_warp=10,
+    gaussian=False,
+    prefilter=False,
+    dtype=np.float32,
+):
+    """Coarse to fine optical flow estimator.
+
+    The iterative Lucas-Kanade (iLK) solver is applied at each level
+    of the image pyramid. iLK [1]_ is a fast and robust alternative to
+    TVL1 algorithm although less accurate for rendering flat surfaces
+    and object boundaries (see [2]_).
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    radius : int, optional
+        Radius of the window considered around each pixel.
+    num_warp : int, optional
+        Number of times moving_image is warped.
+    gaussian : bool, optional
+        If True, a Gaussian kernel is used for the local
+        integration. Otherwise, a uniform kernel is used.
+    prefilter : bool, optional
+        Whether to prefilter the estimated optical flow before each
+        image warp. When True, a median filter with window size 3
+        along each axis is applied. This helps to remove potential
+        outliers.
+    dtype : dtype, optional
+        Output data type: must be floating point. Single precision
+        provides good results and saves memory usage and computation
+        time compared to double precision.
+
+    Returns
+    -------
+    flow : ndarray, shape (reference_image.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    Notes
+    -----
+    - The implemented algorithm is described in **Table2** of [1]_.
+    - Color images are not supported.
+
+    References
+    ----------
+    .. [1] Le Besnerais, G., & Champagnat, F. (2005, September). Dense
+       optical flow by iterative local window registration. In IEEE
+       International Conference on Image Processing 2005 (Vol. 1,
+       pp. I-137). IEEE. :DOI:`10.1109/ICIP.2005.1529706`
+    .. [2] Plyer, A., Le Besnerais, G., & Champagnat,
+       F. (2016). Massively parallel Lucas Kanade optical flow for
+       real-time video processing applications. Journal of Real-Time
+       Image Processing, 11(4), 713-730. :DOI:`10.1007/s11554-014-0423-0`
+
+    Examples
+    --------
+    >>> from skimage.color import rgb2gray
+    >>> from skimage.data import stereo_motorcycle
+    >>> from skimage.registration import optical_flow_ilk
+    >>> reference_image, moving_image, disp = stereo_motorcycle()
+    >>> # --- Convert the images to gray level: color is not supported.
+    >>> reference_image = rgb2gray(reference_image)
+    >>> moving_image = rgb2gray(moving_image)
+    >>> flow = optical_flow_ilk(moving_image, reference_image)
+
+    """
+
+    solver = partial(
+        _ilk, radius=radius, num_warp=num_warp, gaussian=gaussian, prefilter=prefilter
+    )
+
+    if np.dtype(dtype) != _supported_float_type(dtype):
+        msg = f"dtype={dtype} is not supported. Try 'float32' or 'float64.'"
+        raise ValueError(msg)
+
+    return _coarse_to_fine(reference_image, moving_image, solver, dtype=dtype)

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/_optical_flow_utils.py

@@ -0,0 +1,150 @@
+"""Common tools to optical flow algorithms."""
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from ..transform import pyramid_reduce
+from ..util.dtype import _convert
+
+
+def _get_warp_points(grid, flow):
+    """Compute warp point coordinates.
+
+    Parameters
+    ----------
+    grid : iterable
+        The sparse grid to be warped (obtained using
+        ``np.meshgrid(..., sparse=True)).``)
+    flow : ndarray
+        The warping motion field.
+
+    Returns
+    -------
+    out : ndarray
+        The warp point coordinates.
+
+    """
+    out = flow.copy()
+    for idx, g in enumerate(grid):
+        out[idx, ...] += g
+    return out
+
+
+def _resize_flow(flow, shape):
+    """Rescale the values of the vector field (u, v) to the desired shape.
+
+    The values of the output vector field are scaled to the new
+    resolution.
+
+    Parameters
+    ----------
+    flow : ndarray
+        The motion field to be processed.
+    shape : iterable
+        Couple of integers representing the output shape.
+
+    Returns
+    -------
+    rflow : ndarray
+        The resized and rescaled motion field.
+
+    """
+
+    scale = [n / o for n, o in zip(shape, flow.shape[1:])]
+    scale_factor = np.array(scale, dtype=flow.dtype)
+
+    for _ in shape:
+        scale_factor = scale_factor[..., np.newaxis]
+
+    rflow = scale_factor * ndi.zoom(
+        flow, [1] + scale, order=0, mode='nearest', prefilter=False
+    )
+
+    return rflow
+
+
+def _get_pyramid(I, downscale=2.0, nlevel=10, min_size=16):
+    """Construct image pyramid.
+
+    Parameters
+    ----------
+    I : ndarray
+        The image to be preprocessed (Grayscale or RGB).
+    downscale : float
+        The pyramid downscale factor.
+    nlevel : int
+        The maximum number of pyramid levels.
+    min_size : int
+        The minimum size for any dimension of the pyramid levels.
+
+    Returns
+    -------
+    pyramid : list[ndarray]
+        The coarse to fine images pyramid.
+
+    """
+
+    pyramid = [I]
+    size = min(I.shape)
+    count = 1
+
+    while (count < nlevel) and (size > downscale * min_size):
+        J = pyramid_reduce(pyramid[-1], downscale, channel_axis=None)
+        pyramid.append(J)
+        size = min(J.shape)
+        count += 1
+
+    return pyramid[::-1]
+
+
+def _coarse_to_fine(
+    I0, I1, solver, downscale=2, nlevel=10, min_size=16, dtype=np.float32
+):
+    """Generic coarse to fine solver.
+
+    Parameters
+    ----------
+    I0 : ndarray
+        The first grayscale image of the sequence.
+    I1 : ndarray
+        The second grayscale image of the sequence.
+    solver : callable
+        The solver applied at each pyramid level.
+    downscale : float
+        The pyramid downscale factor.
+    nlevel : int
+        The maximum number of pyramid levels.
+    min_size : int
+        The minimum size for any dimension of the pyramid levels.
+    dtype : dtype
+        Output data type.
+
+    Returns
+    -------
+    flow : ndarray
+        The estimated optical flow components for each axis.
+
+    """
+
+    if I0.shape != I1.shape:
+        raise ValueError("Input images should have the same shape")
+
+    if np.dtype(dtype).char not in 'efdg':
+        raise ValueError("Only floating point data type are valid" " for optical flow")
+
+    pyramid = list(
+        zip(
+            _get_pyramid(_convert(I0, dtype), downscale, nlevel, min_size),
+            _get_pyramid(_convert(I1, dtype), downscale, nlevel, min_size),
+        )
+    )
+
+    # Initialization to 0 at coarsest level.
+    flow = np.zeros((pyramid[0][0].ndim,) + pyramid[0][0].shape, dtype=dtype)
+
+    flow = solver(pyramid[0][0], pyramid[0][1], flow)
+
+    for J0, J1 in pyramid[1:]:
+        flow = solver(J0, J1, _resize_flow(flow, J0.shape))
+
+    return flow

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/_phase_cross_correlation.py

@@ -0,0 +1,420 @@
+"""
+Port of Manuel Guizar's code from:
+http://www.mathworks.com/matlabcentral/fileexchange/18401-efficient-subpixel-image-registration-by-cross-correlation
+"""
+
+import itertools
+import warnings
+
+import numpy as np
+from scipy.fft import fftn, ifftn, fftfreq
+from scipy import ndimage as ndi
+
+from ._masked_phase_cross_correlation import _masked_phase_cross_correlation
+
+
+def _upsampled_dft(data, upsampled_region_size, upsample_factor=1, axis_offsets=None):
+    """
+    Upsampled DFT by matrix multiplication.
+
+    This code is intended to provide the same result as if the following
+    operations were performed:
+        - Embed the array "data" in an array that is ``upsample_factor`` times
+          larger in each dimension.  ifftshift to bring the center of the
+          image to (1,1).
+        - Take the FFT of the larger array.
+        - Extract an ``[upsampled_region_size]`` region of the result, starting
+          with the ``[axis_offsets+1]`` element.
+
+    It achieves this result by computing the DFT in the output array without
+    the need to zeropad. Much faster and memory efficient than the zero-padded
+    FFT approach if ``upsampled_region_size`` is much smaller than
+    ``data.size * upsample_factor``.
+
+    Parameters
+    ----------
+    data : array
+        The input data array (DFT of original data) to upsample.
+    upsampled_region_size : integer or tuple of integers, optional
+        The size of the region to be sampled.  If one integer is provided, it
+        is duplicated up to the dimensionality of ``data``.
+    upsample_factor : integer, optional
+        The upsampling factor.  Defaults to 1.
+    axis_offsets : tuple of integers, optional
+        The offsets of the region to be sampled.  Defaults to None (uses
+        image center)
+
+    Returns
+    -------
+    output : ndarray
+            The upsampled DFT of the specified region.
+    """
+    # if people pass in an integer, expand it to a list of equal-sized sections
+    if not hasattr(upsampled_region_size, "__iter__"):
+        upsampled_region_size = [
+            upsampled_region_size,
+        ] * data.ndim
+    else:
+        if len(upsampled_region_size) != data.ndim:
+            raise ValueError(
+                "shape of upsampled region sizes must be equal "
+                "to input data's number of dimensions."
+            )
+
+    if axis_offsets is None:
+        axis_offsets = [
+            0,
+        ] * data.ndim
+    else:
+        if len(axis_offsets) != data.ndim:
+            raise ValueError(
+                "number of axis offsets must be equal to input "
+                "data's number of dimensions."
+            )
+
+    im2pi = 1j * 2 * np.pi
+
+    dim_properties = list(zip(data.shape, upsampled_region_size, axis_offsets))
+
+    for n_items, ups_size, ax_offset in dim_properties[::-1]:
+        kernel = (np.arange(ups_size) - ax_offset)[:, None] * fftfreq(
+            n_items, upsample_factor
+        )
+        kernel = np.exp(-im2pi * kernel)
+        # use kernel with same precision as the data
+        kernel = kernel.astype(data.dtype, copy=False)
+
+        # Equivalent to:
+        #   data[i, j, k] = kernel[i, :] @ data[j, k].T
+        data = np.tensordot(kernel, data, axes=(1, -1))
+    return data
+
+
+def _compute_phasediff(cross_correlation_max):
+    """
+    Compute global phase difference between the two images (should be
+        zero if images are non-negative).
+
+    Parameters
+    ----------
+    cross_correlation_max : complex
+        The complex value of the cross correlation at its maximum point.
+    """
+    return np.arctan2(cross_correlation_max.imag, cross_correlation_max.real)
+
+
+def _compute_error(cross_correlation_max, src_amp, target_amp):
+    """
+    Compute RMS error metric between ``src_image`` and ``target_image``.
+
+    Parameters
+    ----------
+    cross_correlation_max : complex
+        The complex value of the cross correlation at its maximum point.
+    src_amp : float
+        The normalized average image intensity of the source image
+    target_amp : float
+        The normalized average image intensity of the target image
+    """
+    amp = src_amp * target_amp
+    if amp == 0:
+        warnings.warn(
+            "Could not determine RMS error between images with the normalized "
+            f"average intensities {src_amp!r} and {target_amp!r}. Either the "
+            "reference or moving image may be empty.",
+            UserWarning,
+            stacklevel=3,
+        )
+    with np.errstate(invalid="ignore"):
+        error = 1.0 - cross_correlation_max * cross_correlation_max.conj() / amp
+    return np.sqrt(np.abs(error))
+
+
+def _disambiguate_shift(reference_image, moving_image, shift):
+    """Determine the correct real-space shift based on periodic shift.
+
+    When determining a translation shift from phase cross-correlation in
+    Fourier space, the shift is only correct to within a period of the image
+    size along each axis, resulting in $2^n$ possible shifts, where $n$ is the
+    number of dimensions of the image. This function checks the
+    cross-correlation in real space for each of those shifts, and returns the
+    one with the highest cross-correlation.
+
+    The strategy we use is to perform the shift on the moving image *using the
+    'grid-wrap' mode* in `scipy.ndimage`. The moving image's original borders
+    then define $2^n$ quadrants, which we cross-correlate with the reference
+    image in turn using slicing. The entire operation is thus $O(2^n + m)$,
+    where $m$ is the number of pixels in the image (and typically dominates).
+
+    Parameters
+    ----------
+    reference_image : numpy array
+        The reference (non-moving) image.
+    moving_image : numpy array
+        The moving image: applying the shift to this image overlays it on the
+        reference image. Must be the same shape as the reference image.
+    shift : ndarray
+        The shift to apply to each axis of the moving image, *modulo* image
+        size. The length of ``shift`` must be equal to ``moving_image.ndim``.
+
+    Returns
+    -------
+    real_shift : ndarray
+        The shift disambiguated in real space.
+    """
+    shape = reference_image.shape
+    positive_shift = [shift_i % s for shift_i, s in zip(shift, shape)]
+    negative_shift = [shift_i - s for shift_i, s in zip(positive_shift, shape)]
+    subpixel = np.any(np.array(shift) % 1 != 0)
+    interp_order = 3 if subpixel else 0
+    shifted = ndi.shift(moving_image, shift, mode='grid-wrap', order=interp_order)
+    indices = np.round(positive_shift).astype(int)
+    splits_per_dim = [(slice(0, i), slice(i, None)) for i in indices]
+    max_corr = -1.0
+    max_slice = None
+    for test_slice in itertools.product(*splits_per_dim):
+        reference_tile = np.reshape(reference_image[test_slice], -1)
+        moving_tile = np.reshape(shifted[test_slice], -1)
+        corr = -1.0
+        if reference_tile.size > 2:
+            # In the case of zero std, np.corrcoef returns NaN and warns
+            # about division by zero. This is expected and handled below.
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=RuntimeWarning)
+                corr = np.corrcoef(reference_tile, moving_tile)[0, 1]
+        if corr > max_corr:
+            max_corr = corr
+            max_slice = test_slice
+    if max_slice is None:
+        warnings.warn(
+            f"Could not determine real-space shift for periodic shift {shift!r} "
+            f"as requested by `disambiguate=True` (disambiguation is degenerate).",
+            stacklevel=3,
+        )
+        return shift
+    real_shift_acc = []
+    for sl, pos_shift, neg_shift in zip(max_slice, positive_shift, negative_shift):
+        real_shift_acc.append(pos_shift if sl.stop is None else neg_shift)
+
+    return np.array(real_shift_acc)
+
+
+def phase_cross_correlation(
+    reference_image,
+    moving_image,
+    *,
+    upsample_factor=1,
+    space="real",
+    disambiguate=False,
+    reference_mask=None,
+    moving_mask=None,
+    overlap_ratio=0.3,
+    normalization="phase",
+):
+    """Efficient subpixel image translation registration by cross-correlation.
+
+    This code gives the same precision as the FFT upsampled cross-correlation
+    in a fraction of the computation time and with reduced memory requirements.
+    It obtains an initial estimate of the cross-correlation peak by an FFT and
+    then refines the shift estimation by upsampling the DFT only in a small
+    neighborhood of that estimate by means of a matrix-multiply DFT [1]_.
+
+    Parameters
+    ----------
+    reference_image : array
+        Reference image.
+    moving_image : array
+        Image to register. Must be same dimensionality as
+        ``reference_image``.
+    upsample_factor : int, optional
+        Upsampling factor. Images will be registered to within
+        ``1 / upsample_factor`` of a pixel. For example
+        ``upsample_factor == 20`` means the images will be registered
+        within 1/20th of a pixel. Default is 1 (no upsampling).
+        Not used if any of ``reference_mask`` or ``moving_mask`` is not None.
+    space : string, one of "real" or "fourier", optional
+        Defines how the algorithm interprets input data. "real" means
+        data will be FFT'd to compute the correlation, while "fourier"
+        data will bypass FFT of input data. Case insensitive. Not
+        used if any of ``reference_mask`` or ``moving_mask`` is not
+        None.
+    disambiguate : bool
+        The shift returned by this function is only accurate *modulo* the
+        image shape, due to the periodic nature of the Fourier transform. If
+        this parameter is set to ``True``, the *real* space cross-correlation
+        is computed for each possible shift, and the shift with the highest
+        cross-correlation within the overlapping area is returned.
+    reference_mask : ndarray
+        Boolean mask for ``reference_image``. The mask should evaluate
+        to ``True`` (or 1) on valid pixels. ``reference_mask`` should
+        have the same shape as ``reference_image``.
+    moving_mask : ndarray or None, optional
+        Boolean mask for ``moving_image``. The mask should evaluate to ``True``
+        (or 1) on valid pixels. ``moving_mask`` should have the same shape
+        as ``moving_image``. If ``None``, ``reference_mask`` will be used.
+    overlap_ratio : float, optional
+        Minimum allowed overlap ratio between images. The correlation for
+        translations corresponding with an overlap ratio lower than this
+        threshold will be ignored. A lower `overlap_ratio` leads to smaller
+        maximum translation, while a higher `overlap_ratio` leads to greater
+        robustness against spurious matches due to small overlap between
+        masked images. Used only if one of ``reference_mask`` or
+        ``moving_mask`` is not None.
+    normalization : {"phase", None}
+        The type of normalization to apply to the cross-correlation. This
+        parameter is unused when masks (`reference_mask` and `moving_mask`) are
+        supplied.
+
+    Returns
+    -------
+    shift : ndarray
+        Shift vector (in pixels) required to register ``moving_image``
+        with ``reference_image``. Axis ordering is consistent with
+        the axis order of the input array.
+    error : float
+        Translation invariant normalized RMS error between
+        ``reference_image`` and ``moving_image``. For masked cross-correlation
+        this error is not available and NaN is returned.
+    phasediff : float
+        Global phase difference between the two images (should be
+        zero if images are non-negative). For masked cross-correlation
+        this phase difference is not available and NaN is returned.
+
+    Notes
+    -----
+    The use of cross-correlation to estimate image translation has a long
+    history dating back to at least [2]_. The "phase correlation"
+    method (selected by ``normalization="phase"``) was first proposed in [3]_.
+    Publications [1]_ and [2]_ use an unnormalized cross-correlation
+    (``normalization=None``). Which form of normalization is better is
+    application-dependent. For example, the phase correlation method works
+    well in registering images under different illumination, but is not very
+    robust to noise. In a high noise scenario, the unnormalized method may be
+    preferable.
+
+    When masks are provided, a masked normalized cross-correlation algorithm is
+    used [5]_, [6]_.
+
+    References
+    ----------
+    .. [1] Manuel Guizar-Sicairos, Samuel T. Thurman, and James R. Fienup,
+           "Efficient subpixel image registration algorithms,"
+           Optics Letters 33, 156-158 (2008). :DOI:`10.1364/OL.33.000156`
+    .. [2] P. Anuta, Spatial registration of multispectral and multitemporal
+           digital imagery using fast Fourier transform techniques, IEEE Trans.
+           Geosci. Electron., vol. 8, no. 4, pp. 353–368, Oct. 1970.
+           :DOI:`10.1109/TGE.1970.271435`.
+    .. [3] C. D. Kuglin D. C. Hines. The phase correlation image alignment
+           method, Proceeding of IEEE International Conference on Cybernetics
+           and Society, pp. 163-165, New York, NY, USA, 1975, pp. 163–165.
+    .. [4] James R. Fienup, "Invariant error metrics for image reconstruction"
+           Optics Letters 36, 8352-8357 (1997). :DOI:`10.1364/AO.36.008352`
+    .. [5] Dirk Padfield. Masked Object Registration in the Fourier Domain.
+           IEEE Transactions on Image Processing, vol. 21(5),
+           pp. 2706-2718 (2012). :DOI:`10.1109/TIP.2011.2181402`
+    .. [6] D. Padfield. "Masked FFT registration". In Proc. Computer Vision and
+           Pattern Recognition, pp. 2918-2925 (2010).
+           :DOI:`10.1109/CVPR.2010.5540032`
+    """
+    if (reference_mask is not None) or (moving_mask is not None):
+        shift = _masked_phase_cross_correlation(
+            reference_image, moving_image, reference_mask, moving_mask, overlap_ratio
+        )
+        return shift, np.nan, np.nan
+
+    # images must be the same shape
+    if reference_image.shape != moving_image.shape:
+        raise ValueError("images must be same shape")
+
+    # assume complex data is already in Fourier space
+    if space.lower() == 'fourier':
+        src_freq = reference_image
+        target_freq = moving_image
+    # real data needs to be fft'd.
+    elif space.lower() == 'real':
+        src_freq = fftn(reference_image)
+        target_freq = fftn(moving_image)
+    else:
+        raise ValueError('space argument must be "real" of "fourier"')
+
+    # Whole-pixel shift - Compute cross-correlation by an IFFT
+    shape = src_freq.shape
+    image_product = src_freq * target_freq.conj()
+    if normalization == "phase":
+        eps = np.finfo(image_product.real.dtype).eps
+        image_product /= np.maximum(np.abs(image_product), 100 * eps)
+    elif normalization is not None:
+        raise ValueError("normalization must be either phase or None")
+    cross_correlation = ifftn(image_product)
+
+    # Locate maximum
+    maxima = np.unravel_index(
+        np.argmax(np.abs(cross_correlation)), cross_correlation.shape
+    )
+    midpoint = np.array([np.fix(axis_size / 2) for axis_size in shape])
+
+    float_dtype = image_product.real.dtype
+
+    shift = np.stack(maxima).astype(float_dtype, copy=False)
+    shift[shift > midpoint] -= np.array(shape)[shift > midpoint]
+
+    if upsample_factor == 1:
+        src_amp = np.sum(np.real(src_freq * src_freq.conj()))
+        src_amp /= src_freq.size
+        target_amp = np.sum(np.real(target_freq * target_freq.conj()))
+        target_amp /= target_freq.size
+        CCmax = cross_correlation[maxima]
+    # If upsampling > 1, then refine estimate with matrix multiply DFT
+    else:
+        # Initial shift estimate in upsampled grid
+        upsample_factor = np.array(upsample_factor, dtype=float_dtype)
+        shift = np.round(shift * upsample_factor) / upsample_factor
+        upsampled_region_size = np.ceil(upsample_factor * 1.5)
+        # Center of output array at dftshift + 1
+        dftshift = np.fix(upsampled_region_size / 2.0)
+        # Matrix multiply DFT around the current shift estimate
+        sample_region_offset = dftshift - shift * upsample_factor
+        cross_correlation = _upsampled_dft(
+            image_product.conj(),
+            upsampled_region_size,
+            upsample_factor,
+            sample_region_offset,
+        ).conj()
+        # Locate maximum and map back to original pixel grid
+        maxima = np.unravel_index(
+            np.argmax(np.abs(cross_correlation)), cross_correlation.shape
+        )
+        CCmax = cross_correlation[maxima]
+
+        maxima = np.stack(maxima).astype(float_dtype, copy=False)
+        maxima -= dftshift
+
+        shift += maxima / upsample_factor
+
+        src_amp = np.sum(np.real(src_freq * src_freq.conj()))
+        target_amp = np.sum(np.real(target_freq * target_freq.conj()))
+
+    # If its only one row or column the shift along that dimension has no
+    # effect. We set to zero.
+    for dim in range(src_freq.ndim):
+        if shape[dim] == 1:
+            shift[dim] = 0
+
+    if disambiguate:
+        if space.lower() != 'real':
+            reference_image = ifftn(reference_image)
+            moving_image = ifftn(moving_image)
+        shift = _disambiguate_shift(reference_image, moving_image, shift)
+
+    # Redirect user to masked_phase_cross_correlation if NaNs are observed
+    if np.isnan(CCmax) or np.isnan(src_amp) or np.isnan(target_amp):
+        raise ValueError(
+            "NaN values found, please remove NaNs from your "
+            "input data or use the `reference_mask`/`moving_mask` "
+            "keywords, eg: "
+            "phase_cross_correlation(reference_image, moving_image, "
+            "reference_mask=~np.isnan(reference_image), "
+            "moving_mask=~np.isnan(moving_image))"
+        )
+
+    return shift, _compute_error(CCmax, src_amp, target_amp), _compute_phasediff(CCmax)

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/tests/test_ilk.py

@@ -0,0 +1,101 @@
+import numpy as np
+import pytest
+
+from skimage._shared.utils import _supported_float_type
+from skimage.registration import optical_flow_ilk
+from .test_tvl1 import _sin_flow_gen
+
+
+@pytest.mark.parametrize('dtype', [np.float16, np.float32, np.float64])
+@pytest.mark.parametrize('gaussian', [True, False])
+@pytest.mark.parametrize('prefilter', [True, False])
+def test_2d_motion(dtype, gaussian, prefilter):
+    # Generate synthetic data
+    rng = np.random.default_rng(0)
+    image0 = rng.normal(size=(256, 256))
+    gt_flow, image1 = _sin_flow_gen(image0)
+    image1 = image1.astype(dtype, copy=False)
+    float_dtype = _supported_float_type(dtype)
+    # Estimate the flow
+    flow = optical_flow_ilk(
+        image0, image1, gaussian=gaussian, prefilter=prefilter, dtype=float_dtype
+    )
+    assert flow.dtype == _supported_float_type(dtype)
+    # Assert that the average absolute error is less then half a pixel
+    assert abs(flow - gt_flow).mean() < 0.5
+
+    if dtype != float_dtype:
+        with pytest.raises(ValueError):
+            optical_flow_ilk(
+                image0, image1, gaussian=gaussian, prefilter=prefilter, dtype=dtype
+            )
+
+
+@pytest.mark.parametrize('gaussian', [True, False])
+@pytest.mark.parametrize('prefilter', [True, False])
+def test_3d_motion(gaussian, prefilter):
+    # Generate synthetic data
+    rng = np.random.default_rng(123)
+    image0 = rng.normal(size=(50, 55, 60))
+    gt_flow, image1 = _sin_flow_gen(image0, npics=3)
+    # Estimate the flow
+    flow = optical_flow_ilk(
+        image0, image1, radius=5, gaussian=gaussian, prefilter=prefilter
+    )
+
+    # Assert that the average absolute error is less then half a pixel
+    assert abs(flow - gt_flow).mean() < 0.5
+
+
+def test_no_motion_2d():
+    rng = np.random.default_rng(0)
+    img = rng.normal(size=(256, 256))
+
+    flow = optical_flow_ilk(img, img)
+
+    assert np.all(flow == 0)
+
+
+def test_no_motion_3d():
+    rng = np.random.default_rng(0)
+    img = rng.normal(size=(64, 64, 64))
+
+    flow = optical_flow_ilk(img, img)
+
+    assert np.all(flow == 0)
+
+
+def test_optical_flow_dtype():
+    # Generate synthetic data
+    rng = np.random.default_rng(0)
+    image0 = rng.normal(size=(256, 256))
+    gt_flow, image1 = _sin_flow_gen(image0)
+    # Estimate the flow at double precision
+    flow_f64 = optical_flow_ilk(image0, image1, dtype='float64')
+
+    assert flow_f64.dtype == 'float64'
+
+    # Estimate the flow at single precision
+    flow_f32 = optical_flow_ilk(image0, image1, dtype='float32')
+
+    assert flow_f32.dtype == 'float32'
+
+    # Assert that floating point precision does not affect the quality
+    # of the estimated flow
+
+    assert abs(flow_f64 - flow_f32).mean() < 1e-3
+
+
+def test_incompatible_shapes():
+    rng = np.random.default_rng(0)
+    I0 = rng.normal(size=(256, 256))
+    I1 = rng.normal(size=(255, 256))
+    with pytest.raises(ValueError):
+        u, v = optical_flow_ilk(I0, I1)
+
+
+def test_wrong_dtype():
+    rng = np.random.default_rng(0)
+    img = rng.normal(size=(256, 256))
+    with pytest.raises(ValueError):
+        u, v = optical_flow_ilk(img, img, dtype='int')

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/tests/test_masked_phase_cross_correlation.py

@@ -0,0 +1,278 @@
+import numpy as np
+import pytest
+from numpy.testing import (
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+    assert_array_less,
+    assert_equal,
+)
+from scipy.ndimage import fourier_shift, shift as real_shift
+import scipy.fft as fft
+
+from skimage._shared.testing import fetch
+from skimage._shared.utils import _supported_float_type
+from skimage.data import camera, brain
+
+
+from skimage.io import imread
+from skimage.registration._masked_phase_cross_correlation import (
+    _masked_phase_cross_correlation as masked_register_translation,
+    cross_correlate_masked,
+)
+from skimage.registration import phase_cross_correlation
+
+
+def test_masked_registration_vs_phase_cross_correlation():
+    """masked_register_translation should give the same results as
+    phase_cross_correlation in the case of trivial masks."""
+    reference_image = camera()
+    shift = (-7, 12)
+    shifted = np.real(fft.ifft2(fourier_shift(fft.fft2(reference_image), shift)))
+    trivial_mask = np.ones_like(reference_image)
+
+    nonmasked_result, *_ = phase_cross_correlation(reference_image, shifted)
+    masked_result = masked_register_translation(
+        reference_image, shifted, reference_mask=trivial_mask, overlap_ratio=1 / 10
+    )
+
+    assert_equal(nonmasked_result, masked_result)
+
+
+def test_masked_registration_random_masks():
+    """masked_register_translation should be able to register translations
+    between images even with random masks."""
+    # See random number generator for reproducible results
+    np.random.seed(23)
+
+    reference_image = camera()
+    shift = (-7, 12)
+    shifted = np.real(fft.ifft2(fourier_shift(fft.fft2(reference_image), shift)))
+
+    # Random masks with 75% of pixels being valid
+    ref_mask = np.random.choice([True, False], reference_image.shape, p=[3 / 4, 1 / 4])
+    shifted_mask = np.random.choice([True, False], shifted.shape, p=[3 / 4, 1 / 4])
+
+    measured_shift = masked_register_translation(
+        reference_image, shifted, reference_mask=ref_mask, moving_mask=shifted_mask
+    )
+    assert_equal(measured_shift, -np.array(shift))
+
+
+def test_masked_registration_3d_contiguous_mask():
+    """masked_register_translation should be able to register translations
+    between volumes with contiguous masks."""
+    ref_vol = brain()[:, ::2, ::2]
+
+    offset = (1, -5, 10)
+
+    # create square mask
+    ref_mask = np.zeros_like(ref_vol, dtype=bool)
+    ref_mask[:-2, 75:100, 75:100] = True
+    ref_shifted = real_shift(ref_vol, offset)
+
+    measured_offset = masked_register_translation(
+        ref_vol, ref_shifted, reference_mask=ref_mask, moving_mask=ref_mask
+    )
+
+    assert_equal(offset, -np.array(measured_offset))
+
+
+def test_masked_registration_random_masks_non_equal_sizes():
+    """masked_register_translation should be able to register
+    translations between images that are not the same size even
+    with random masks."""
+    # See random number generator for reproducible results
+    np.random.seed(23)
+
+    reference_image = camera()
+    shift = (-7, 12)
+    shifted = np.real(fft.ifft2(fourier_shift(fft.fft2(reference_image), shift)))
+
+    # Crop the shifted image
+    shifted = shifted[64:-64, 64:-64]
+
+    # Random masks with 75% of pixels being valid
+    ref_mask = np.random.choice([True, False], reference_image.shape, p=[3 / 4, 1 / 4])
+    shifted_mask = np.random.choice([True, False], shifted.shape, p=[3 / 4, 1 / 4])
+
+    measured_shift = masked_register_translation(
+        reference_image,
+        shifted,
+        reference_mask=np.ones_like(ref_mask),
+        moving_mask=np.ones_like(shifted_mask),
+    )
+    assert_equal(measured_shift, -np.array(shift))
+
+
+def test_masked_registration_padfield_data():
+    """Masked translation registration should behave like in the original
+    publication"""
+    # Test translated from MATLABimplementation `MaskedFFTRegistrationTest`
+    # file. You can find the source code here:
+    # http://www.dirkpadfield.com/Home/MaskedFFTRegistrationCode.zip
+
+    shifts = [(75, 75), (-130, 130), (130, 130)]
+    for xi, yi in shifts:
+        fixed_image = imread(fetch(f'registration/tests/data/OriginalX{xi}Y{yi}.png'))
+        moving_image = imread(
+            fetch(f'registration/tests/data/TransformedX{xi}Y{yi}.png')
+        )
+
+        # Valid pixels are 1
+        fixed_mask = fixed_image != 0
+        moving_mask = moving_image != 0
+
+        # Note that shifts in x and y and shifts in cols and rows
+        shift_y, shift_x = masked_register_translation(
+            fixed_image,
+            moving_image,
+            reference_mask=fixed_mask,
+            moving_mask=moving_mask,
+            overlap_ratio=0.1,
+        )
+        # Note: by looking at the test code from Padfield's
+        # MaskedFFTRegistrationCode repository, the
+        # shifts were not xi and yi, but xi and -yi
+        assert_equal((shift_x, shift_y), (-xi, yi))
+
+
+@pytest.mark.parametrize('dtype', [np.float16, np.float32, np.float64])
+def test_cross_correlate_masked_output_shape(dtype):
+    """Masked normalized cross-correlation should return a shape
+    of N + M + 1 for each transform axis."""
+    shape1 = (15, 4, 5)
+    shape2 = (6, 12, 7)
+    expected_full_shape = tuple(np.array(shape1) + np.array(shape2) - 1)
+    expected_same_shape = shape1
+
+    arr1 = np.zeros(shape1, dtype=dtype)
+    arr2 = np.zeros(shape2, dtype=dtype)
+    # Trivial masks
+    m1 = np.ones_like(arr1)
+    m2 = np.ones_like(arr2)
+
+    float_dtype = _supported_float_type(dtype)
+
+    full_xcorr = cross_correlate_masked(arr1, arr2, m1, m2, axes=(0, 1, 2), mode='full')
+    assert_equal(full_xcorr.shape, expected_full_shape)
+    assert full_xcorr.dtype == float_dtype
+
+    same_xcorr = cross_correlate_masked(arr1, arr2, m1, m2, axes=(0, 1, 2), mode='same')
+    assert_equal(same_xcorr.shape, expected_same_shape)
+    assert same_xcorr.dtype == float_dtype
+
+
+def test_cross_correlate_masked_test_against_mismatched_dimensions():
+    """Masked normalized cross-correlation should raise an error if array
+    dimensions along non-transformation axes are mismatched."""
+    shape1 = (23, 1, 1)
+    shape2 = (6, 2, 2)
+
+    arr1 = np.zeros(shape1)
+    arr2 = np.zeros(shape2)
+
+    # Trivial masks
+    m1 = np.ones_like(arr1)
+    m2 = np.ones_like(arr2)
+
+    with pytest.raises(ValueError):
+        cross_correlate_masked(arr1, arr2, m1, m2, axes=(1, 2))
+
+
+def test_cross_correlate_masked_output_range():
+    """Masked normalized cross-correlation should return between 1 and -1."""
+    # See random number generator for reproducible results
+    np.random.seed(23)
+
+    # Array dimensions must match along non-transformation axes, in
+    # this case
+    # axis 0
+    shape1 = (15, 4, 5)
+    shape2 = (15, 12, 7)
+
+    # Initial array ranges between -5 and 5
+    arr1 = 10 * np.random.random(shape1) - 5
+    arr2 = 10 * np.random.random(shape2) - 5
+
+    # random masks
+    m1 = np.random.choice([True, False], arr1.shape)
+    m2 = np.random.choice([True, False], arr2.shape)
+
+    xcorr = cross_correlate_masked(arr1, arr2, m1, m2, axes=(1, 2))
+
+    # No assert array less or equal, so we add an eps
+    # Also could not find an `assert_array_greater`, Use (-xcorr) instead
+    eps = np.finfo(float).eps
+    assert_array_less(xcorr, 1 + eps)
+    assert_array_less(-xcorr, 1 + eps)
+
+
+def test_cross_correlate_masked_side_effects():
+    """Masked normalized cross-correlation should not modify the inputs."""
+    shape1 = (2, 2, 2)
+    shape2 = (2, 2, 2)
+
+    arr1 = np.zeros(shape1)
+    arr2 = np.zeros(shape2)
+
+    # Trivial masks
+    m1 = np.ones_like(arr1)
+    m2 = np.ones_like(arr2)
+
+    for arr in (arr1, arr2, m1, m2):
+        arr.setflags(write=False)
+
+    cross_correlate_masked(arr1, arr2, m1, m2)
+
+
+def test_cross_correlate_masked_over_axes():
+    """Masked normalized cross-correlation over axes should be
+    equivalent to a loop over non-transform axes."""
+    # See random number generator for reproducible results
+    np.random.seed(23)
+
+    arr1 = np.random.random((8, 8, 5))
+    arr2 = np.random.random((8, 8, 5))
+
+    m1 = np.random.choice([True, False], arr1.shape)
+    m2 = np.random.choice([True, False], arr2.shape)
+
+    # Loop over last axis
+    with_loop = np.empty_like(arr1, dtype=complex)
+    for index in range(arr1.shape[-1]):
+        with_loop[:, :, index] = cross_correlate_masked(
+            arr1[:, :, index],
+            arr2[:, :, index],
+            m1[:, :, index],
+            m2[:, :, index],
+            axes=(0, 1),
+            mode='same',
+        )
+
+    over_axes = cross_correlate_masked(arr1, arr2, m1, m2, axes=(0, 1), mode='same')
+
+    assert_array_almost_equal(with_loop, over_axes)
+
+
+def test_cross_correlate_masked_autocorrelation_trivial_masks():
+    """Masked normalized cross-correlation between identical arrays
+    should reduce to an autocorrelation even with random masks."""
+    # See random number generator for reproducible results
+    np.random.seed(23)
+
+    arr1 = camera()
+
+    # Random masks with 75% of pixels being valid
+    m1 = np.random.choice([True, False], arr1.shape, p=[3 / 4, 1 / 4])
+    m2 = np.random.choice([True, False], arr1.shape, p=[3 / 4, 1 / 4])
+
+    xcorr = cross_correlate_masked(
+        arr1, arr1, m1, m2, axes=(0, 1), mode='same', overlap_ratio=0
+    ).real
+    max_index = np.unravel_index(np.argmax(xcorr), xcorr.shape)
+
+    # Autocorrelation should have maximum in center of array
+    # uint8 inputs will be processed in float32, so reduce decimal to 5
+    assert_almost_equal(xcorr.max(), 1, decimal=5)
+    assert_array_equal(max_index, np.array(arr1.shape) / 2)

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/tests/test_phase_cross_correlation.py

@@ -0,0 +1,251 @@
+import itertools
+import warnings
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+from scipy.ndimage import fourier_shift
+import scipy.fft as fft
+
+from skimage import img_as_float
+from skimage._shared._warnings import expected_warnings
+from skimage._shared.testing import assert_stacklevel
+from skimage._shared.utils import _supported_float_type
+from skimage.data import camera, binary_blobs, eagle
+from skimage.registration._phase_cross_correlation import (
+    phase_cross_correlation,
+    _upsampled_dft,
+)
+
+
+@pytest.mark.parametrize('normalization', [None, 'phase'])
+def test_correlation(normalization):
+    reference_image = fft.fftn(camera())
+    shift = (-7, 12)
+    shifted_image = fourier_shift(reference_image, shift)
+
+    # pixel precision
+    result, _, _ = phase_cross_correlation(
+        reference_image, shifted_image, space="fourier", normalization=normalization
+    )
+    assert_allclose(result[:2], -np.array(shift))
+
+
+@pytest.mark.parametrize('normalization', ['nonexisting'])
+def test_correlation_invalid_normalization(normalization):
+    reference_image = fft.fftn(camera())
+    shift = (-7, 12)
+    shifted_image = fourier_shift(reference_image, shift)
+
+    # pixel precision
+    with pytest.raises(ValueError):
+        phase_cross_correlation(
+            reference_image, shifted_image, space="fourier", normalization=normalization
+        )
+
+
+@pytest.mark.parametrize('normalization', [None, 'phase'])
+def test_subpixel_precision(normalization):
+    reference_image = fft.fftn(camera())
+    subpixel_shift = (-2.4, 1.32)
+    shifted_image = fourier_shift(reference_image, subpixel_shift)
+
+    # subpixel precision
+    result, _, _ = phase_cross_correlation(
+        reference_image,
+        shifted_image,
+        upsample_factor=100,
+        space="fourier",
+        normalization=normalization,
+    )
+    assert_allclose(result[:2], -np.array(subpixel_shift), atol=0.05)
+
+
+@pytest.mark.parametrize('dtype', [np.float16, np.float32, np.float64])
+def test_real_input(dtype):
+    reference_image = camera().astype(dtype, copy=False)
+    subpixel_shift = (-2.4, 1.32)
+    shifted_image = fourier_shift(fft.fftn(reference_image), subpixel_shift)
+    shifted_image = fft.ifftn(shifted_image).real.astype(dtype, copy=False)
+
+    # subpixel precision
+    result, error, diffphase = phase_cross_correlation(
+        reference_image, shifted_image, upsample_factor=100
+    )
+    assert result.dtype == _supported_float_type(dtype)
+    assert_allclose(result[:2], -np.array(subpixel_shift), atol=0.05)
+
+
+def test_size_one_dimension_input():
+    # take a strip of the input image
+    reference_image = fft.fftn(camera()[:, 15]).reshape((-1, 1))
+    subpixel_shift = (-2.4, 4)
+    shifted_image = fourier_shift(reference_image, subpixel_shift)
+
+    # subpixel precision
+    result, error, diffphase = phase_cross_correlation(
+        reference_image, shifted_image, upsample_factor=20, space="fourier"
+    )
+    assert_allclose(result[:2], -np.array((-2.4, 0)), atol=0.05)
+
+
+def test_3d_input():
+    phantom = img_as_float(binary_blobs(length=32, n_dim=3))
+    reference_image = fft.fftn(phantom)
+    shift = (-2.0, 1.0, 5.0)
+    shifted_image = fourier_shift(reference_image, shift)
+
+    result, error, diffphase = phase_cross_correlation(
+        reference_image, shifted_image, space="fourier"
+    )
+    assert_allclose(result, -np.array(shift), atol=0.05)
+
+    # subpixel precision now available for 3-D data
+
+    subpixel_shift = (-2.3, 1.7, 5.4)
+    shifted_image = fourier_shift(reference_image, subpixel_shift)
+    result, error, diffphase = phase_cross_correlation(
+        reference_image, shifted_image, upsample_factor=100, space="fourier"
+    )
+    assert_allclose(result, -np.array(subpixel_shift), atol=0.05)
+
+
+def test_unknown_space_input():
+    image = np.ones((5, 5))
+    with pytest.raises(ValueError):
+        phase_cross_correlation(image, image, space="frank")
+
+
+def test_wrong_input():
+    # Dimensionality mismatch
+    image = np.ones((5, 5, 1))
+    template = np.ones((5, 5))
+    with pytest.raises(ValueError):
+        phase_cross_correlation(template, image)
+
+    # Size mismatch
+    image = np.ones((5, 5))
+    template = np.ones((4, 4))
+    with pytest.raises(ValueError):
+        phase_cross_correlation(template, image)
+
+    # NaN values in data
+    image = np.ones((5, 5))
+    image[0][0] = np.nan
+    template = np.ones((5, 5))
+    with expected_warnings(
+        [
+            r"invalid value encountered in true_divide"
+            + r"|"
+            + r"invalid value encountered in divide"
+            + r"|\A\Z"
+        ]
+    ):
+        with pytest.raises(ValueError):
+            phase_cross_correlation(template, image)
+
+
+def test_4d_input_pixel():
+    phantom = img_as_float(binary_blobs(length=32, n_dim=4))
+    reference_image = fft.fftn(phantom)
+    shift = (-2.0, 1.0, 5.0, -3)
+    shifted_image = fourier_shift(reference_image, shift)
+    result, error, diffphase = phase_cross_correlation(
+        reference_image, shifted_image, space="fourier"
+    )
+    assert_allclose(result, -np.array(shift), atol=0.05)
+
+
+def test_4d_input_subpixel():
+    phantom = img_as_float(binary_blobs(length=32, n_dim=4))
+    reference_image = fft.fftn(phantom)
+    subpixel_shift = (-2.3, 1.7, 5.4, -3.2)
+    shifted_image = fourier_shift(reference_image, subpixel_shift)
+    result, error, diffphase = phase_cross_correlation(
+        reference_image, shifted_image, upsample_factor=10, space="fourier"
+    )
+    assert_allclose(result, -np.array(subpixel_shift), atol=0.05)
+
+
+def test_mismatch_upsampled_region_size():
+    with pytest.raises(ValueError):
+        _upsampled_dft(np.ones((4, 4)), upsampled_region_size=[3, 2, 1, 4])
+
+
+def test_mismatch_offsets_size():
+    with pytest.raises(ValueError):
+        _upsampled_dft(np.ones((4, 4)), 3, axis_offsets=[3, 2, 1, 4])
+
+
+@pytest.mark.parametrize(
+    ('shift0', 'shift1'),
+    itertools.product((100, -100, 350, -350), (100, -100, 350, -350)),
+)
+def test_disambiguate_2d(shift0, shift1):
+    image = eagle()[500:, 900:]  # use a highly textured part of image
+    shift = (shift0, shift1)
+    origin0 = []
+    for s in shift:
+        if s > 0:
+            origin0.append(0)
+        else:
+            origin0.append(-s)
+    origin1 = np.array(origin0) + shift
+    slice0 = tuple(slice(o, o + 450) for o in origin0)
+    slice1 = tuple(slice(o, o + 450) for o in origin1)
+    reference = image[slice0]
+    moving = image[slice1]
+    computed_shift, _, _ = phase_cross_correlation(
+        reference,
+        moving,
+        disambiguate=True,
+    )
+    np.testing.assert_equal(shift, computed_shift)
+
+
+def test_invalid_value_in_division_warnings():
+    """Regression test for https://github.com/scikit-image/scikit-image/issues/7146."""
+    im1 = np.zeros((100, 100))
+    im1[50, 50] = 1
+    im2 = np.zeros((100, 100))
+    im2[60, 60] = 1
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        phase_cross_correlation(im1, im2, disambiguate=True)
+
+
+@pytest.mark.parametrize('disambiguate', [True, False])
+def test_disambiguate_zero_shift(disambiguate):
+    """When the shift is 0, disambiguation becomes degenerate.
+
+    Some quadrants become size 0, which prevents computation of
+    cross-correlation. This test ensures that nothing bad happens in that
+    scenario.
+    """
+    image = camera()
+    computed_shift, _, _ = phase_cross_correlation(
+        image,
+        image,
+        disambiguate=disambiguate,
+    )
+    assert isinstance(computed_shift, np.ndarray)
+    np.testing.assert_array_equal(computed_shift, np.array((0.0, 0.0)))
+
+
+@pytest.mark.parametrize('null_images', [(1, 0), (0, 1), (0, 0)])
+def test_disambiguate_empty_image(null_images):
+    """When the image is empty, disambiguation becomes degenerate."""
+    image = camera()
+    with pytest.warns(UserWarning) as records:
+        shift, error, phasediff = phase_cross_correlation(
+            image * null_images[0], image * null_images[1], disambiguate=True
+        )
+        assert_stacklevel(records, offset=-3)
+    np.testing.assert_array_equal(shift, np.array([0.0, 0.0]))
+    assert np.isnan(error)
+    assert phasediff == 0.0
+
+    # Check warnings
+    assert len(records) == 2
+    assert "Could not determine real-space shift" in records[0].message.args[0]
+    assert "Could not determine RMS error between images" in records[1].message.args[0]

infer_4_47_1/lib/python3.10/site-packages/skimage/registration/tests/test_tvl1.py

@@ -0,0 +1,118 @@
+import numpy as np
+import pytest
+
+from skimage._shared.utils import _supported_float_type
+from skimage.registration import optical_flow_tvl1
+from skimage.transform import warp
+
+
+def _sin_flow_gen(image0, max_motion=4.5, npics=5):
+    """Generate a synthetic ground truth optical flow with a sinusoid as
+      first component.
+
+    Parameters
+    ----------
+    image0: ndarray
+        The base image to be warped.
+    max_motion: float
+        Maximum flow magnitude.
+    npics: int
+        Number of sinusoid pics.
+
+    Returns
+    -------
+    flow, image1 : ndarray
+        The synthetic ground truth optical flow with a sinusoid as
+        first component and the corresponding warped image.
+
+    """
+    grid = np.meshgrid(*[np.arange(n) for n in image0.shape], indexing='ij')
+    grid = np.stack(grid)
+    gt_flow = np.zeros_like(grid, dtype=float)
+    gt_flow[0, ...] = max_motion * np.sin(grid[0] / grid[0].max() * npics * np.pi)
+    image1 = warp(image0, grid - gt_flow, mode='edge')
+    return gt_flow, image1
+
+
+@pytest.mark.parametrize('dtype', [np.float16, np.float32, np.float64])
+def test_2d_motion(dtype):
+    # Generate synthetic data
+    rng = np.random.default_rng(0)
+    image0 = rng.normal(size=(256, 256))
+    gt_flow, image1 = _sin_flow_gen(image0)
+    image1 = image1.astype(dtype, copy=False)
+    float_dtype = _supported_float_type(dtype)
+    # Estimate the flow
+    flow = optical_flow_tvl1(image0, image1, attachment=5, dtype=float_dtype)
+    assert flow.dtype == float_dtype
+    # Assert that the average absolute error is less then half a pixel
+    assert abs(flow - gt_flow).mean() < 0.5
+
+    if dtype != float_dtype:
+        with pytest.raises(ValueError):
+            optical_flow_tvl1(image0, image1, attachment=5, dtype=dtype)
+
+
+def test_3d_motion():
+    # Generate synthetic data
+    rng = np.random.default_rng(0)
+    image0 = rng.normal(size=(100, 100, 100))
+    gt_flow, image1 = _sin_flow_gen(image0)
+    # Estimate the flow
+    flow = optical_flow_tvl1(image0, image1, attachment=10)
+    # Assert that the average absolute error is less then half a pixel
+    assert abs(flow - gt_flow).mean() < 0.5
+
+
+def test_no_motion_2d():
+    rng = np.random.default_rng(0)
+    img = rng.normal(size=(256, 256))
+
+    flow = optical_flow_tvl1(img, img)
+
+    assert np.all(flow == 0)
+
+
+def test_no_motion_3d():
+    rng = np.random.default_rng(0)
+    img = rng.normal(size=(64, 64, 64))
+
+    flow = optical_flow_tvl1(img, img)
+
+    assert np.all(flow == 0)
+
+
+def test_optical_flow_dtype():
+    # Generate synthetic data
+    rng = np.random.default_rng(0)
+    image0 = rng.normal(size=(256, 256))
+    gt_flow, image1 = _sin_flow_gen(image0)
+    # Estimate the flow at double precision
+    flow_f64 = optical_flow_tvl1(image0, image1, attachment=5, dtype=np.float64)
+
+    assert flow_f64.dtype == np.float64
+
+    # Estimate the flow at single precision
+    flow_f32 = optical_flow_tvl1(image0, image1, attachment=5, dtype=np.float32)
+
+    assert flow_f32.dtype == np.float32
+
+    # Assert that floating point precision does not affect the quality
+    # of the estimated flow
+
+    assert np.abs(flow_f64 - flow_f32).mean() < 1e-3
+
+
+def test_incompatible_shapes():
+    rng = np.random.default_rng(0)
+    I0 = rng.normal(size=(256, 256))
+    I1 = rng.normal(size=(128, 256))
+    with pytest.raises(ValueError):
+        u, v = optical_flow_tvl1(I0, I1)
+
+
+def test_wrong_dtype():
+    rng = np.random.default_rng(0)
+    img = rng.normal(size=(256, 256))
+    with pytest.raises(ValueError):
+        u, v = optical_flow_tvl1(img, img, dtype=np.int64)

infer_4_47_1/lib/python3.10/site-packages/skimage/transform/__init__.pyi

@@ -0,0 +1,86 @@
+# Explicitly setting `__all__` is necessary for type inference engines
+# to know which symbols are exported. See
+# https://peps.python.org/pep-0484/#stub-files
+
+__all__ = [
+    'hough_circle',
+    'hough_ellipse',
+    'hough_line',
+    'probabilistic_hough_line',
+    'hough_circle_peaks',
+    'hough_line_peaks',
+    'radon',
+    'iradon',
+    'iradon_sart',
+    'order_angles_golden_ratio',
+    'frt2',
+    'ifrt2',
+    'integral_image',
+    'integrate',
+    'warp',
+    'warp_coords',
+    'warp_polar',
+    'estimate_transform',
+    'matrix_transform',
+    'EuclideanTransform',
+    'SimilarityTransform',
+    'AffineTransform',
+    'ProjectiveTransform',
+    'EssentialMatrixTransform',
+    'FundamentalMatrixTransform',
+    'PolynomialTransform',
+    'PiecewiseAffineTransform',
+    'ThinPlateSplineTransform',
+    'swirl',
+    'resize',
+    'resize_local_mean',
+    'rotate',
+    'rescale',
+    'downscale_local_mean',
+    'pyramid_reduce',
+    'pyramid_expand',
+    'pyramid_gaussian',
+    'pyramid_laplacian',
+]
+
+from .hough_transform import (
+    hough_line,
+    hough_line_peaks,
+    probabilistic_hough_line,
+    hough_circle,
+    hough_circle_peaks,
+    hough_ellipse,
+)
+from .radon_transform import radon, iradon, iradon_sart, order_angles_golden_ratio
+from .finite_radon_transform import frt2, ifrt2
+from .integral import integral_image, integrate
+from ._geometric import (
+    estimate_transform,
+    matrix_transform,
+    EuclideanTransform,
+    SimilarityTransform,
+    AffineTransform,
+    ProjectiveTransform,
+    FundamentalMatrixTransform,
+    EssentialMatrixTransform,
+    PolynomialTransform,
+    PiecewiseAffineTransform,
+)
+from ._thin_plate_splines import ThinPlateSplineTransform
+from ._warps import (
+    swirl,
+    resize,
+    rotate,
+    rescale,
+    downscale_local_mean,
+    warp,
+    warp_coords,
+    warp_polar,
+    resize_local_mean,
+)
+from .pyramids import (
+    pyramid_reduce,
+    pyramid_expand,
+    pyramid_gaussian,
+    pyramid_laplacian,
+)